Revert filescoped (#2227)

* Revert "Add git blame entry (#2226)" This reverts commit 239286737d. * Revert "Turn on file scoped namespaces (#2225)" This reverts commit 34fb4cca2a.
2025-06-30 15:42:48 -05:00 · 2022-08-29 15:53:48 -04:00
parent 239286737d
commit bae03feffe
1208 changed files with 74317 additions and 73126 deletions
--- a/test/Core.Test/Services/LocalAttachmentStorageServiceTests.cs
+++ b/test/Core.Test/Services/LocalAttachmentStorageServiceTests.cs
@ -11,75 +11,194 @@ using Bit.Test.Common.AutoFixture.Attributes;
 using NSubstitute;
 using Xunit;

-namespace Bit.Core.Test.Services;
-
-public class LocalAttachmentStorageServiceTests
+namespace Bit.Core.Test.Services
 {
-
-    private void AssertFileCreation(string expectedPath, string expectedFileContents)
+    public class LocalAttachmentStorageServiceTests
    {
-        Assert.True(File.Exists(expectedPath));
-        Assert.Equal(expectedFileContents, File.ReadAllText(expectedPath));
-    }

-    [Theory]
-    [InlineCustomAutoData(new[] { typeof(UserCipher), typeof(MetaData) })]
-    [InlineCustomAutoData(new[] { typeof(UserCipher), typeof(MetaDataWithoutContainer) })]
-    [InlineCustomAutoData(new[] { typeof(UserCipher), typeof(MetaDataWithoutKey) })]
-    public async Task UploadNewAttachmentAsync_Success(string stream, Cipher cipher, CipherAttachment.MetaData attachmentData)
-    {
-        using (var tempDirectory = new TempDirectory())
+        private void AssertFileCreation(string expectedPath, string expectedFileContents)
        {
-            var sutProvider = GetSutProvider(tempDirectory);
-
-            await sutProvider.Sut.UploadNewAttachmentAsync(new MemoryStream(Encoding.UTF8.GetBytes(stream)),
-                cipher, attachmentData);
-
-            AssertFileCreation($"{tempDirectory}/{cipher.Id}/{attachmentData.AttachmentId}", stream);
+            Assert.True(File.Exists(expectedPath));
+            Assert.Equal(expectedFileContents, File.ReadAllText(expectedPath));
        }
-    }

-    [Theory]
-    [InlineCustomAutoData(new[] { typeof(OrganizationCipher), typeof(MetaData) })]
-    [InlineCustomAutoData(new[] { typeof(OrganizationCipher), typeof(MetaDataWithoutContainer) })]
-    [InlineCustomAutoData(new[] { typeof(OrganizationCipher), typeof(MetaDataWithoutKey) })]
-    public async Task UploadShareAttachmentAsync_Success(string stream, Cipher cipher, CipherAttachment.MetaData attachmentData)
-    {
-        using (var tempDirectory = new TempDirectory())
+        [Theory]
+        [InlineCustomAutoData(new[] { typeof(UserCipher), typeof(MetaData) })]
+        [InlineCustomAutoData(new[] { typeof(UserCipher), typeof(MetaDataWithoutContainer) })]
+        [InlineCustomAutoData(new[] { typeof(UserCipher), typeof(MetaDataWithoutKey) })]
+        public async Task UploadNewAttachmentAsync_Success(string stream, Cipher cipher, CipherAttachment.MetaData attachmentData)
        {
-            var sutProvider = GetSutProvider(tempDirectory);
+            using (var tempDirectory = new TempDirectory())
+            {
+                var sutProvider = GetSutProvider(tempDirectory);

-            await sutProvider.Sut.UploadShareAttachmentAsync(new MemoryStream(Encoding.UTF8.GetBytes(stream)),
-                cipher.Id, cipher.OrganizationId.Value, attachmentData);
+                await sutProvider.Sut.UploadNewAttachmentAsync(new MemoryStream(Encoding.UTF8.GetBytes(stream)),
+                    cipher, attachmentData);

-            AssertFileCreation($"{tempDirectory}/temp/{cipher.Id}/{cipher.OrganizationId}/{attachmentData.AttachmentId}", stream);
+                AssertFileCreation($"{tempDirectory}/{cipher.Id}/{attachmentData.AttachmentId}", stream);
+            }
        }
-    }

-    [Theory]
-    [InlineCustomAutoData(new[] { typeof(OrganizationCipher), typeof(MetaData) })]
-    [InlineCustomAutoData(new[] { typeof(OrganizationCipher), typeof(MetaDataWithoutContainer) })]
-    [InlineCustomAutoData(new[] { typeof(OrganizationCipher), typeof(MetaDataWithoutKey) })]
-    public async Task StartShareAttachmentAsync_NoSource_NoWork(Cipher cipher, CipherAttachment.MetaData attachmentData)
-    {
-        using (var tempDirectory = new TempDirectory())
+        [Theory]
+        [InlineCustomAutoData(new[] { typeof(OrganizationCipher), typeof(MetaData) })]
+        [InlineCustomAutoData(new[] { typeof(OrganizationCipher), typeof(MetaDataWithoutContainer) })]
+        [InlineCustomAutoData(new[] { typeof(OrganizationCipher), typeof(MetaDataWithoutKey) })]
+        public async Task UploadShareAttachmentAsync_Success(string stream, Cipher cipher, CipherAttachment.MetaData attachmentData)
        {
-            var sutProvider = GetSutProvider(tempDirectory);
+            using (var tempDirectory = new TempDirectory())
+            {
+                var sutProvider = GetSutProvider(tempDirectory);

-            await sutProvider.Sut.StartShareAttachmentAsync(cipher.Id, cipher.OrganizationId.Value, attachmentData);
+                await sutProvider.Sut.UploadShareAttachmentAsync(new MemoryStream(Encoding.UTF8.GetBytes(stream)),
+                    cipher.Id, cipher.OrganizationId.Value, attachmentData);

-            Assert.False(File.Exists($"{tempDirectory}/{cipher.Id}/{attachmentData.AttachmentId}"));
-            Assert.False(File.Exists($"{tempDirectory}/{cipher.Id}/{attachmentData.AttachmentId}"));
+                AssertFileCreation($"{tempDirectory}/temp/{cipher.Id}/{cipher.OrganizationId}/{attachmentData.AttachmentId}", stream);
+            }
        }
-    }

-    [Theory]
-    [InlineCustomAutoData(new[] { typeof(OrganizationCipher), typeof(MetaData) })]
-    [InlineCustomAutoData(new[] { typeof(OrganizationCipher), typeof(MetaDataWithoutContainer) })]
-    [InlineCustomAutoData(new[] { typeof(OrganizationCipher), typeof(MetaDataWithoutKey) })]
-    public async Task StartShareAttachmentAsync_NoDest_NoWork(string source, Cipher cipher, CipherAttachment.MetaData attachmentData)
-    {
-        using (var tempDirectory = new TempDirectory())
+        [Theory]
+        [InlineCustomAutoData(new[] { typeof(OrganizationCipher), typeof(MetaData) })]
+        [InlineCustomAutoData(new[] { typeof(OrganizationCipher), typeof(MetaDataWithoutContainer) })]
+        [InlineCustomAutoData(new[] { typeof(OrganizationCipher), typeof(MetaDataWithoutKey) })]
+        public async Task StartShareAttachmentAsync_NoSource_NoWork(Cipher cipher, CipherAttachment.MetaData attachmentData)
+        {
+            using (var tempDirectory = new TempDirectory())
+            {
+                var sutProvider = GetSutProvider(tempDirectory);
+
+                await sutProvider.Sut.StartShareAttachmentAsync(cipher.Id, cipher.OrganizationId.Value, attachmentData);
+
+                Assert.False(File.Exists($"{tempDirectory}/{cipher.Id}/{attachmentData.AttachmentId}"));
+                Assert.False(File.Exists($"{tempDirectory}/{cipher.Id}/{attachmentData.AttachmentId}"));
+            }
+        }
+
+        [Theory]
+        [InlineCustomAutoData(new[] { typeof(OrganizationCipher), typeof(MetaData) })]
+        [InlineCustomAutoData(new[] { typeof(OrganizationCipher), typeof(MetaDataWithoutContainer) })]
+        [InlineCustomAutoData(new[] { typeof(OrganizationCipher), typeof(MetaDataWithoutKey) })]
+        public async Task StartShareAttachmentAsync_NoDest_NoWork(string source, Cipher cipher, CipherAttachment.MetaData attachmentData)
+        {
+            using (var tempDirectory = new TempDirectory())
+            {
+                var sutProvider = GetSutProvider(tempDirectory);
+
+                var sourcePath = $"{tempDirectory}/temp/{cipher.Id}/{cipher.OrganizationId}/{attachmentData.AttachmentId}";
+                var destPath = $"{tempDirectory}/{cipher.Id}/{attachmentData.AttachmentId}";
+                var rollBackPath = $"{tempDirectory}/temp/{cipher.Id}/{attachmentData.AttachmentId}";
+                Directory.CreateDirectory(Path.GetDirectoryName(sourcePath));
+                File.WriteAllText(sourcePath, source);
+
+                await sutProvider.Sut.StartShareAttachmentAsync(cipher.Id, cipher.OrganizationId.Value, attachmentData);
+
+                Assert.True(File.Exists(sourcePath));
+                Assert.Equal(source, File.ReadAllText(sourcePath));
+                Assert.False(File.Exists(destPath));
+                Assert.False(File.Exists(rollBackPath));
+            }
+        }
+
+
+        [Theory]
+        [InlineCustomAutoData(new[] { typeof(OrganizationCipher), typeof(MetaData) })]
+        [InlineCustomAutoData(new[] { typeof(OrganizationCipher), typeof(MetaDataWithoutContainer) })]
+        [InlineCustomAutoData(new[] { typeof(OrganizationCipher), typeof(MetaDataWithoutKey) })]
+        public async Task StartShareAttachmentAsync_Success(string source, string destOriginal, Cipher cipher, CipherAttachment.MetaData attachmentData)
+        {
+            using (var tempDirectory = new TempDirectory())
+            {
+                await StartShareAttachmentAsync(source, destOriginal, cipher, attachmentData, tempDirectory);
+            }
+        }
+
+        [Theory]
+        [InlineCustomAutoData(new[] { typeof(OrganizationCipher), typeof(MetaData) })]
+        [InlineCustomAutoData(new[] { typeof(OrganizationCipher), typeof(MetaDataWithoutContainer) })]
+        [InlineCustomAutoData(new[] { typeof(OrganizationCipher), typeof(MetaDataWithoutKey) })]
+        public async Task RollbackShareAttachmentAsync_Success(string source, string destOriginal, Cipher cipher, CipherAttachment.MetaData attachmentData)
+        {
+            using (var tempDirectory = new TempDirectory())
+            {
+                var sutProvider = GetSutProvider(tempDirectory);
+
+                var sourcePath = $"{tempDirectory}/temp/{cipher.Id}/{cipher.OrganizationId}/{attachmentData.AttachmentId}";
+                var destPath = $"{tempDirectory}/{cipher.Id}/{attachmentData.AttachmentId}";
+                var rollBackPath = $"{tempDirectory}/temp/{cipher.Id}/{attachmentData.AttachmentId}";
+
+                await StartShareAttachmentAsync(source, destOriginal, cipher, attachmentData, tempDirectory);
+                await sutProvider.Sut.RollbackShareAttachmentAsync(cipher.Id, cipher.OrganizationId.Value, attachmentData, "Not Used Here");
+
+                Assert.True(File.Exists(destPath));
+                Assert.Equal(destOriginal, File.ReadAllText(destPath));
+                Assert.False(File.Exists(sourcePath));
+                Assert.False(File.Exists(rollBackPath));
+            }
+        }
+
+        [Theory]
+        [InlineCustomAutoData(new[] { typeof(UserCipher), typeof(MetaData) })]
+        [InlineCustomAutoData(new[] { typeof(UserCipher), typeof(MetaDataWithoutContainer) })]
+        [InlineCustomAutoData(new[] { typeof(UserCipher), typeof(MetaDataWithoutKey) })]
+        public async Task DeleteAttachmentAsync_Success(Cipher cipher, CipherAttachment.MetaData attachmentData)
+        {
+            using (var tempDirectory = new TempDirectory())
+            {
+                var sutProvider = GetSutProvider(tempDirectory);
+
+                var expectedPath = $"{tempDirectory}/{cipher.Id}/{attachmentData.AttachmentId}";
+                Directory.CreateDirectory(Path.GetDirectoryName(expectedPath));
+                File.Create(expectedPath).Close();
+
+                await sutProvider.Sut.DeleteAttachmentAsync(cipher.Id, attachmentData);
+
+                Assert.False(File.Exists(expectedPath));
+            }
+        }
+
+        [Theory]
+        [InlineUserCipherAutoData]
+        [InlineOrganizationCipherAutoData]
+        public async Task CleanupAsync_Succes(Cipher cipher)
+        {
+            using (var tempDirectory = new TempDirectory())
+            {
+                var sutProvider = GetSutProvider(tempDirectory);
+
+                var tempPath = $"{tempDirectory}/temp/{cipher.Id}";
+                var permPath = $"{tempDirectory}/{cipher.Id}";
+                Directory.CreateDirectory(tempPath);
+                Directory.CreateDirectory(permPath);
+
+                await sutProvider.Sut.CleanupAsync(cipher.Id);
+
+                Assert.False(Directory.Exists(tempPath));
+                Assert.True(Directory.Exists(permPath));
+            }
+        }
+
+        [Theory]
+        [InlineUserCipherAutoData]
+        [InlineOrganizationCipherAutoData]
+        public async Task DeleteAttachmentsForCipherAsync_Succes(Cipher cipher)
+        {
+            using (var tempDirectory = new TempDirectory())
+            {
+                var sutProvider = GetSutProvider(tempDirectory);
+
+                var tempPath = $"{tempDirectory}/temp/{cipher.Id}";
+                var permPath = $"{tempDirectory}/{cipher.Id}";
+                Directory.CreateDirectory(tempPath);
+                Directory.CreateDirectory(permPath);
+
+                await sutProvider.Sut.DeleteAttachmentsForCipherAsync(cipher.Id);
+
+                Assert.True(Directory.Exists(tempPath));
+                Assert.False(Directory.Exists(permPath));
+            }
+        }
+
+        private async Task StartShareAttachmentAsync(string source, string destOriginal, Cipher cipher,
+            CipherAttachment.MetaData attachmentData, TempDirectory tempDirectory)
        {
            var sutProvider = GetSutProvider(tempDirectory);

@ -87,144 +206,26 @@ public class LocalAttachmentStorageServiceTests
            var destPath = $"{tempDirectory}/{cipher.Id}/{attachmentData.AttachmentId}";
            var rollBackPath = $"{tempDirectory}/temp/{cipher.Id}/{attachmentData.AttachmentId}";
            Directory.CreateDirectory(Path.GetDirectoryName(sourcePath));
+            Directory.CreateDirectory(Path.GetDirectoryName(destPath));
            File.WriteAllText(sourcePath, source);
+            File.WriteAllText(destPath, destOriginal);

            await sutProvider.Sut.StartShareAttachmentAsync(cipher.Id, cipher.OrganizationId.Value, attachmentData);

-            Assert.True(File.Exists(sourcePath));
-            Assert.Equal(source, File.ReadAllText(sourcePath));
-            Assert.False(File.Exists(destPath));
-            Assert.False(File.Exists(rollBackPath));
-        }
-    }
-
-
-    [Theory]
-    [InlineCustomAutoData(new[] { typeof(OrganizationCipher), typeof(MetaData) })]
-    [InlineCustomAutoData(new[] { typeof(OrganizationCipher), typeof(MetaDataWithoutContainer) })]
-    [InlineCustomAutoData(new[] { typeof(OrganizationCipher), typeof(MetaDataWithoutKey) })]
-    public async Task StartShareAttachmentAsync_Success(string source, string destOriginal, Cipher cipher, CipherAttachment.MetaData attachmentData)
-    {
-        using (var tempDirectory = new TempDirectory())
-        {
-            await StartShareAttachmentAsync(source, destOriginal, cipher, attachmentData, tempDirectory);
-        }
-    }
-
-    [Theory]
-    [InlineCustomAutoData(new[] { typeof(OrganizationCipher), typeof(MetaData) })]
-    [InlineCustomAutoData(new[] { typeof(OrganizationCipher), typeof(MetaDataWithoutContainer) })]
-    [InlineCustomAutoData(new[] { typeof(OrganizationCipher), typeof(MetaDataWithoutKey) })]
-    public async Task RollbackShareAttachmentAsync_Success(string source, string destOriginal, Cipher cipher, CipherAttachment.MetaData attachmentData)
-    {
-        using (var tempDirectory = new TempDirectory())
-        {
-            var sutProvider = GetSutProvider(tempDirectory);
-
-            var sourcePath = $"{tempDirectory}/temp/{cipher.Id}/{cipher.OrganizationId}/{attachmentData.AttachmentId}";
-            var destPath = $"{tempDirectory}/{cipher.Id}/{attachmentData.AttachmentId}";
-            var rollBackPath = $"{tempDirectory}/temp/{cipher.Id}/{attachmentData.AttachmentId}";
-
-            await StartShareAttachmentAsync(source, destOriginal, cipher, attachmentData, tempDirectory);
-            await sutProvider.Sut.RollbackShareAttachmentAsync(cipher.Id, cipher.OrganizationId.Value, attachmentData, "Not Used Here");
-
-            Assert.True(File.Exists(destPath));
-            Assert.Equal(destOriginal, File.ReadAllText(destPath));
            Assert.False(File.Exists(sourcePath));
-            Assert.False(File.Exists(rollBackPath));
+            Assert.True(File.Exists(destPath));
+            Assert.Equal(source, File.ReadAllText(destPath));
+            Assert.True(File.Exists(rollBackPath));
+            Assert.Equal(destOriginal, File.ReadAllText(rollBackPath));
        }
-    }

-    [Theory]
-    [InlineCustomAutoData(new[] { typeof(UserCipher), typeof(MetaData) })]
-    [InlineCustomAutoData(new[] { typeof(UserCipher), typeof(MetaDataWithoutContainer) })]
-    [InlineCustomAutoData(new[] { typeof(UserCipher), typeof(MetaDataWithoutKey) })]
-    public async Task DeleteAttachmentAsync_Success(Cipher cipher, CipherAttachment.MetaData attachmentData)
-    {
-        using (var tempDirectory = new TempDirectory())
+        private SutProvider<LocalAttachmentStorageService> GetSutProvider(TempDirectory tempDirectory)
        {
-            var sutProvider = GetSutProvider(tempDirectory);
+            var fixture = new Fixture().WithAutoNSubstitutions();
+            fixture.Freeze<IGlobalSettings>().Attachment.BaseDirectory.Returns(tempDirectory.Directory);
+            fixture.Freeze<IGlobalSettings>().Attachment.BaseUrl.Returns(Guid.NewGuid().ToString());

-            var expectedPath = $"{tempDirectory}/{cipher.Id}/{attachmentData.AttachmentId}";
-            Directory.CreateDirectory(Path.GetDirectoryName(expectedPath));
-            File.Create(expectedPath).Close();
-
-            await sutProvider.Sut.DeleteAttachmentAsync(cipher.Id, attachmentData);
-
-            Assert.False(File.Exists(expectedPath));
+            return new SutProvider<LocalAttachmentStorageService>(fixture).Create();
        }
    }
-
-    [Theory]
-    [InlineUserCipherAutoData]
-    [InlineOrganizationCipherAutoData]
-    public async Task CleanupAsync_Succes(Cipher cipher)
-    {
-        using (var tempDirectory = new TempDirectory())
-        {
-            var sutProvider = GetSutProvider(tempDirectory);
-
-            var tempPath = $"{tempDirectory}/temp/{cipher.Id}";
-            var permPath = $"{tempDirectory}/{cipher.Id}";
-            Directory.CreateDirectory(tempPath);
-            Directory.CreateDirectory(permPath);
-
-            await sutProvider.Sut.CleanupAsync(cipher.Id);
-
-            Assert.False(Directory.Exists(tempPath));
-            Assert.True(Directory.Exists(permPath));
-        }
-    }
-
-    [Theory]
-    [InlineUserCipherAutoData]
-    [InlineOrganizationCipherAutoData]
-    public async Task DeleteAttachmentsForCipherAsync_Succes(Cipher cipher)
-    {
-        using (var tempDirectory = new TempDirectory())
-        {
-            var sutProvider = GetSutProvider(tempDirectory);
-
-            var tempPath = $"{tempDirectory}/temp/{cipher.Id}";
-            var permPath = $"{tempDirectory}/{cipher.Id}";
-            Directory.CreateDirectory(tempPath);
-            Directory.CreateDirectory(permPath);
-
-            await sutProvider.Sut.DeleteAttachmentsForCipherAsync(cipher.Id);
-
-            Assert.True(Directory.Exists(tempPath));
-            Assert.False(Directory.Exists(permPath));
-        }
-    }
-
-    private async Task StartShareAttachmentAsync(string source, string destOriginal, Cipher cipher,
-        CipherAttachment.MetaData attachmentData, TempDirectory tempDirectory)
-    {
-        var sutProvider = GetSutProvider(tempDirectory);
-
-        var sourcePath = $"{tempDirectory}/temp/{cipher.Id}/{cipher.OrganizationId}/{attachmentData.AttachmentId}";
-        var destPath = $"{tempDirectory}/{cipher.Id}/{attachmentData.AttachmentId}";
-        var rollBackPath = $"{tempDirectory}/temp/{cipher.Id}/{attachmentData.AttachmentId}";
-        Directory.CreateDirectory(Path.GetDirectoryName(sourcePath));
-        Directory.CreateDirectory(Path.GetDirectoryName(destPath));
-        File.WriteAllText(sourcePath, source);
-        File.WriteAllText(destPath, destOriginal);
-
-        await sutProvider.Sut.StartShareAttachmentAsync(cipher.Id, cipher.OrganizationId.Value, attachmentData);
-
-        Assert.False(File.Exists(sourcePath));
-        Assert.True(File.Exists(destPath));
-        Assert.Equal(source, File.ReadAllText(destPath));
-        Assert.True(File.Exists(rollBackPath));
-        Assert.Equal(destOriginal, File.ReadAllText(rollBackPath));
-    }
-
-    private SutProvider<LocalAttachmentStorageService> GetSutProvider(TempDirectory tempDirectory)
-    {
-        var fixture = new Fixture().WithAutoNSubstitutions();
-        fixture.Freeze<IGlobalSettings>().Attachment.BaseDirectory.Returns(tempDirectory.Directory);
-        fixture.Freeze<IGlobalSettings>().Attachment.BaseUrl.Returns(Guid.NewGuid().ToString());
-
-        return new SutProvider<LocalAttachmentStorageService>(fixture).Create();
-    }
 }