nhyatt/bitwarden
1
0
Fork 0
mirror of https://github.com/bitwarden/server.git synced 2025-06-30 23:52:50 -05:00
Code Activity

Postgres & MySql Support For Self-Hosted Installations (#1386)

Browse Source 
* EF Database Support Init (#1221)

* scaffolding for ef support

* deleted old postgres repos

* added tables to oncreate

* updated all the things to .NET 5

* Addition to #1221: Migrated DockerFiles from dotnet/3.1 to  5.0 (#1223)

* Migrated DockerFiles from dotnet/3.1 to  5.0

* Migrated SSO/Dockerfile from dotnet 3.1 to 5.0

Co-authored-by: Daniel James Smith <djsmith85@users.noreply.github.com>

* EFDatabaseSupport: Updated links and description in README.md and SETUP.md (#1232)

* Updated requirements in README.md

* Updated link to documentation of app-secrets

* upgraded dotnet version to 5.0

* Ef database support implementation examples (#1265)

* mostly finished testing the user repo

* finished testing user repo

* finished org, user, ssoconfig, and ssouser ef implementations

* removed unused prop

* fixed a sql file

* fixed a spacing issue

* fixed a spacing issue

* removed extra database creation

* refactoring

* MsSql => SqlServer

* refactoring

* code review fixes

* build fix

* code review

* continued attempts to fix the the build

* skipped another test

* finished all create test

* initial pass at several repos

* continued building out repos

* initial pass at several repos

* initial pass at device repo

* initial pass at collection repo

* initial run of all Entity Framework implementations

* signup, signin, create/edit ciphers works

* sync working

* all web vault pages seem to load with 100% 200s

* bulkcopy, folders, and favorites

* group and collection management

* sso, groups, emergency access, send

* get basic creates matching on all repos

* got everything building again post merge

* removed some IDE config files

* cleanup

* no more notimplemented methods in the cipher repo

* no more not implementeds everywhere

* cleaned up schema/navigation properties and fixed tests

* removed a sql comment that was written in c# style

* fixed build issues from merge

* removed unsupported db providers

* formatting

* code review refactors

* naming cleanup for queries

* added provider methods

* cipher repo cleanup

* implemented several missing procedures from the EF implementation surround account revision dates, keys, and storage

* fixed the build

* added a null check

* consolidated some cipher repo methods

* formatting fix

* cleaned up indentation of queries

* removed .idea file

* generated postgres migrations

* added mysql migrations

* formatting

* Bug Fixes & Formatting

* Formatting

* fixed a bug with bulk import when using MySql

* code review fixes

* fixed the build

* implemented new methods

* formatting

* fixed the build

* cleaned up select statements in ef queries

* formatting

* formatting

* formatting

Co-authored-by: Daniel James Smith <djsmith85@users.noreply.github.com>
This commit is contained in:
Addison Beck
2021-07-08 12:35:48 -04:00
committed by GitHub
parent be13eb153a
commit b13dda2799
251 changed files with 21099 additions and 608 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
test/Core.Test/AutoFixture/Attributes/CiSkippedTheory.cs Normal file
View File

@ -0,0 +1,16 @@
using System;
namespace Bit.Core.Test.AutoFixture.Attributes
{
public sealed class CiSkippedTheory : Xunit.TheoryAttribute
{
private static bool IsGithubActions() => Environment.GetEnvironmentVariable("CI") != null;
public CiSkippedTheory()
{
if(IsGithubActions())
{
Skip = "Ignore during CI builds";
}
}
}
}

118
test/Core.Test/AutoFixture/CipherFixtures.cs
View File

@ -1,7 +1,20 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using AutoFixture;
using AutoFixture.Kernel;
using Bit.Core.Models.Data;
using Bit.Core.Models.Table;
using Bit.Core.Repositories.EntityFramework;
using Bit.Core.Test.AutoFixture.Attributes;
using Bit.Core.Test.AutoFixture.EntityFrameworkRepositoryFixtures;
using Bit.Core.Test.AutoFixture.GlobalSettingsFixtures;
using Bit.Core.Test.AutoFixture.OrganizationFixtures;
using Bit.Core.Test.AutoFixture.OrganizationUserFixtures;
using Bit.Core.Test.AutoFixture.Relays;
using Bit.Core.Test.AutoFixture.TransactionFixtures;
using Bit.Core.Test.AutoFixture.UserFixtures;
using Core.Models.Data;
namespace Bit.Core.Test.AutoFixture.CipherFixtures
@ -34,6 +47,90 @@ namespace Bit.Core.Test.AutoFixture.CipherFixtures
}
}
internal class CipherBuilder: ISpecimenBuilder
{
public bool OrganizationOwned { get; set; }
public object Create(object request, ISpecimenContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var type = request as Type;
if (type == null || (type != typeof(Cipher) && type != typeof(List<Cipher>)))
{
return new NoSpecimen();
}
var fixture = new Fixture();
fixture.Customizations.Insert(0, new MaxLengthStringRelay());
fixture.Customizations.Add(new IgnoreVirtualMembersCustomization());
if (!OrganizationOwned)
{
fixture.Customize<Cipher>(composer => composer
.Without(c => c.OrganizationId));
}
// Can't test valid Favorites and Folders without creating those values inide each test,
// since we won't have any UserIds until the test is running & creating data
fixture.Customize<Cipher>(c => c
.Without(e => e.Favorites)
.Without(e => e.Folders));
//
var serializerOptions = new JsonSerializerOptions(){
PropertyNamingPolicy = JsonNamingPolicy.CamelCase
};
if(type == typeof(Cipher))
{
var obj = fixture.WithAutoNSubstitutions().Create<Cipher>();
var cipherData = fixture.WithAutoNSubstitutions().Create<CipherLoginData>();
var cipherAttachements = fixture.WithAutoNSubstitutions().Create<List<CipherAttachment>>();
obj.Data = JsonSerializer.Serialize(cipherData, serializerOptions);
obj.Attachments = JsonSerializer.Serialize(cipherAttachements, serializerOptions);
return obj;
}
if (type == typeof(List<Cipher>))
{
var ciphers = fixture.WithAutoNSubstitutions().CreateMany<Cipher>().ToArray();
for (var i = 0; i < ciphers.Count(); i++ )
{
var cipherData = fixture.WithAutoNSubstitutions().Create<CipherLoginData>();
var cipherAttachements = fixture.WithAutoNSubstitutions().Create<List<CipherAttachment>>();
ciphers[i].Data = JsonSerializer.Serialize(cipherData, serializerOptions);
ciphers[i].Attachments = JsonSerializer.Serialize(cipherAttachements, serializerOptions);
}
return ciphers;
}
return new NoSpecimen();
}
}
internal class EfCipher: ICustomization
{
public bool OrganizationOwned { get; set; }
public void Customize(IFixture fixture)
{
fixture.Customizations.Add(new GlobalSettingsBuilder());
fixture.Customizations.Add(new CipherBuilder(){
OrganizationOwned = OrganizationOwned
});
fixture.Customizations.Add(new UserBuilder());
fixture.Customizations.Add(new OrganizationBuilder());
fixture.Customizations.Add(new OrganizationUserBuilder());
fixture.Customizations.Add(new EfRepositoryListBuilder<CipherRepository>());
fixture.Customizations.Add(new EfRepositoryListBuilder<OrganizationRepository>());
fixture.Customizations.Add(new EfRepositoryListBuilder<OrganizationUserRepository>());
fixture.Customizations.Add(new EfRepositoryListBuilder<UserRepository>());
fixture.Customizations.Add(new EfRepositoryListBuilder<CollectionRepository>());
}
}
internal class UserCipherAutoDataAttribute : CustomAutoDataAttribute
{
public UserCipherAutoDataAttribute(string userId = null) : base(new SutProviderCustomization(),
@ -67,4 +164,25 @@ namespace Bit.Core.Test.AutoFixture.CipherFixtures
typeof(OrganizationCipher) }, values)
{ }
}
internal class EfUserCipherAutoDataAttribute : CustomAutoDataAttribute
{
public EfUserCipherAutoDataAttribute() : base(new SutProviderCustomization(), new EfCipher())
{ }
}
internal class EfOrganizationCipherAutoDataAttribute : CustomAutoDataAttribute
{
public EfOrganizationCipherAutoDataAttribute() : base(new SutProviderCustomization(), new EfCipher(){
OrganizationOwned = true,
})
{ }
}
internal class InlineEfCipherAutoDataAttribute : InlineCustomAutoDataAttribute
{
public InlineEfCipherAutoDataAttribute(params object[] values) : base(new[] { typeof(SutProviderCustomization),
typeof(EfCipher) }, values)
{ }
}
}

74
test/Core.Test/AutoFixture/CollectionCipherFixtures.cs Normal file
View File

@ -0,0 +1,74 @@
using AutoFixture;
using TableModel = Bit.Core.Models.Table;
using Bit.Core.Test.AutoFixture.Attributes;
using Bit.Core.Test.AutoFixture.GlobalSettingsFixtures;
using AutoMapper;
using Bit.Core.Models.EntityFramework;
using Bit.Core.Models;
using System.Collections.Generic;
using Bit.Core.Enums;
using AutoFixture.Kernel;
using System;
using Bit.Core.Test.AutoFixture.OrganizationFixtures;
using Bit.Core.Repositories.EntityFramework;
using Bit.Core.Test.AutoFixture.EntityFrameworkRepositoryFixtures;
using Bit.Core.Test.AutoFixture.TransactionFixtures;
using Bit.Core.Test.AutoFixture.Relays;
using Bit.Core.Test.AutoFixture.CollectionFixtures;
using Bit.Core.Test.AutoFixture.CipherFixtures;
using Bit.Core.Test.AutoFixture.UserFixtures;
namespace Bit.Core.Test.AutoFixture.CollectionCipherFixtures
{
internal class CollectionCipherBuilder: ISpecimenBuilder
{
public object Create(object request, ISpecimenContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var type = request as Type;
if (type == null || type != typeof(TableModel.CollectionCipher))
{
return new NoSpecimen();
}
var fixture = new Fixture();
fixture.Customizations.Insert(0, new MaxLengthStringRelay());
var obj = fixture.WithAutoNSubstitutions().Create<TableModel.CollectionCipher>();
return obj;
}
}
internal class EfCollectionCipher: ICustomization
{
public void Customize(IFixture fixture)
{
fixture.Customizations.Add(new IgnoreVirtualMembersCustomization());
fixture.Customizations.Add(new GlobalSettingsBuilder());
fixture.Customizations.Add(new CollectionCipherBuilder());
fixture.Customizations.Add(new CollectionBuilder());
fixture.Customizations.Add(new CipherBuilder());
fixture.Customizations.Add(new UserBuilder());
fixture.Customizations.Add(new EfRepositoryListBuilder<CollectionCipherRepository>());
fixture.Customizations.Add(new EfRepositoryListBuilder<CollectionRepository>());
fixture.Customizations.Add(new EfRepositoryListBuilder<CipherRepository>());
fixture.Customizations.Add(new EfRepositoryListBuilder<UserRepository>());
}
}
internal class EfCollectionCipherAutoDataAttribute : CustomAutoDataAttribute
{
public EfCollectionCipherAutoDataAttribute() : base(new SutProviderCustomization(), new EfCollectionCipher())
{ }
}
internal class InlineEfCollectionCipherAutoDataAttribute : InlineCustomAutoDataAttribute
{
public InlineEfCollectionCipherAutoDataAttribute(params object[] values) : base(new[] { typeof(SutProviderCustomization),
typeof(EfCollectionCipher) }, values)
{ }
}
}

85
test/Core.Test/AutoFixture/CollectionFixtures.cs
View File

@ -1,12 +1,73 @@
using Bit.Core.Test.AutoFixture.Attributes;
using Bit.Core.Test.AutoFixture.OrganizationFixtures;
namespace Bit.Core.Test.AutoFixture
{
internal class CollectionAutoDataAttribute : CustomAutoDataAttribute
{
public CollectionAutoDataAttribute() : base(new SutProviderCustomization(), new Organization())
{ }
}
}
using AutoFixture;
using TableModel = Bit.Core.Models.Table;
using Bit.Core.Test.AutoFixture.Attributes;
using Bit.Core.Test.AutoFixture.GlobalSettingsFixtures;
using AutoMapper;
using Bit.Core.Models.EntityFramework;
using Bit.Core.Models;
using System.Collections.Generic;
using Bit.Core.Enums;
using AutoFixture.Kernel;
using System;
using Bit.Core.Test.AutoFixture.OrganizationFixtures;
using Bit.Core.Repositories.EntityFramework;
using Bit.Core.Test.AutoFixture.EntityFrameworkRepositoryFixtures;
using Bit.Core.Test.AutoFixture.TransactionFixtures;
using Bit.Core.Test.AutoFixture.Relays;
namespace Bit.Core.Test.AutoFixture.CollectionFixtures
{
internal class CollectionBuilder: ISpecimenBuilder
{
public object Create(object request, ISpecimenContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var type = request as Type;
if (type == null || type != typeof(TableModel.Collection))
{
return new NoSpecimen();
}
var fixture = new Fixture();
fixture.Customizations.Insert(0, new MaxLengthStringRelay());
var obj = fixture.WithAutoNSubstitutions().Create<TableModel.Collection>();
return obj;
}
}
internal class EfCollection: ICustomization
{
public void Customize(IFixture fixture)
{
fixture.Customizations.Add(new IgnoreVirtualMembersCustomization());
fixture.Customizations.Add(new GlobalSettingsBuilder());
fixture.Customizations.Add(new CollectionBuilder());
fixture.Customizations.Add(new OrganizationBuilder());
fixture.Customizations.Add(new EfRepositoryListBuilder<CollectionRepository>());
fixture.Customizations.Add(new EfRepositoryListBuilder<OrganizationRepository>());
}
}
internal class EfCollectionAutoDataAttribute : CustomAutoDataAttribute
{
public EfCollectionAutoDataAttribute() : base(new SutProviderCustomization(), new EfCollection())
{ }
}
internal class InlineEfCollectionAutoDataAttribute : InlineCustomAutoDataAttribute
{
public InlineEfCollectionAutoDataAttribute(params object[] values) : base(new[] { typeof(SutProviderCustomization),
typeof(EfCollection) }, values)
{ }
}
internal class CollectionAutoDataAttribute : CustomAutoDataAttribute
{
public CollectionAutoDataAttribute() : base(new SutProviderCustomization(), new Bit.Core.Test.AutoFixture.OrganizationFixtures.Organization())
{ }
}
}

69
test/Core.Test/AutoFixture/DeviceFixtures.cs Normal file
View File

@ -0,0 +1,69 @@
using AutoFixture;
using TableModel = Bit.Core.Models.Table;
using Bit.Core.Test.AutoFixture.Attributes;
using Bit.Core.Test.AutoFixture.GlobalSettingsFixtures;
using AutoMapper;
using Bit.Core.Models.EntityFramework;
using Bit.Core.Models;
using System.Collections.Generic;
using Bit.Core.Enums;
using AutoFixture.Kernel;
using System;
using Bit.Core.Test.AutoFixture.OrganizationFixtures;
using Bit.Core.Repositories.EntityFramework;
using Bit.Core.Test.AutoFixture.EntityFrameworkRepositoryFixtures;
using Bit.Core.Test.AutoFixture.UserFixtures;
using Bit.Core.Test.AutoFixture.TransactionFixtures;
using Bit.Core.Test.AutoFixture.Relays;
namespace Bit.Core.Test.AutoFixture.DeviceFixtures
{
internal class DeviceBuilder: ISpecimenBuilder
{
public object Create(object request, ISpecimenContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var type = request as Type;
if (type == null || type != typeof(TableModel.Device))
{
return new NoSpecimen();
}
var fixture = new Fixture();
fixture.Customizations.Insert(0, new MaxLengthStringRelay());
var obj = fixture.WithAutoNSubstitutions().Create<TableModel.Device>();
return obj;
}
}
internal class EfDevice: ICustomization
{
public void Customize(IFixture fixture)
{
fixture.Customizations.Add(new IgnoreVirtualMembersCustomization());
fixture.Customizations.Add(new GlobalSettingsBuilder());
fixture.Customizations.Add(new DeviceBuilder());
fixture.Customizations.Add(new UserBuilder());
fixture.Customizations.Add(new EfRepositoryListBuilder<DeviceRepository>());
fixture.Customizations.Add(new EfRepositoryListBuilder<UserRepository>());
}
}
internal class EfDeviceAutoDataAttribute : CustomAutoDataAttribute
{
public EfDeviceAutoDataAttribute() : base(new SutProviderCustomization(), new EfDevice())
{ }
}
internal class InlineEfDeviceAutoDataAttribute : InlineCustomAutoDataAttribute
{
public InlineEfDeviceAutoDataAttribute(params object[] values) : base(new[] { typeof(SutProviderCustomization),
typeof(EfDevice) }, values)
{ }
}
}

71
test/Core.Test/AutoFixture/EmergencyAccessFixtures.cs Normal file
View File

@ -0,0 +1,71 @@
using AutoFixture;
using TableModel = Bit.Core.Models.Table;
using Bit.Core.Test.AutoFixture.Attributes;
using Bit.Core.Test.AutoFixture.GlobalSettingsFixtures;
using AutoMapper;
using Bit.Core.Models.EntityFramework;
using Bit.Core.Models;
using System.Collections.Generic;
using Bit.Core.Enums;
using AutoFixture.Kernel;
using System;
using Bit.Core.Test.AutoFixture.OrganizationFixtures;
using Bit.Core.Repositories.EntityFramework;
using Bit.Core.Test.AutoFixture.EntityFrameworkRepositoryFixtures;
using Bit.Core.Test.AutoFixture.UserFixtures;
using Bit.Core.Test.AutoFixture.TransactionFixtures;
using AutoFixture.DataAnnotations;
using Bit.Core.Test.AutoFixture.Relays;
namespace Bit.Core.Test.AutoFixture.EmergencyAccessFixtures
{
internal class EmergencyAccessBuilder: ISpecimenBuilder
{
public object Create(object request, ISpecimenContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var type = request as Type;
if (type == null || type != typeof(TableModel.EmergencyAccess))
{
return new NoSpecimen();
}
var fixture = new Fixture();
fixture.Customizations.Insert(0, new MaxLengthStringRelay());
var obj = fixture.Create<TableModel.EmergencyAccess>();
return obj;
}
}
internal class EfEmergencyAccess: ICustomization
{
public void Customize(IFixture fixture)
{
// TODO: Make a base EF Customization with IgnoreVirtualMembers/GlobalSettings/All repos and inherit
fixture.Customizations.Add(new IgnoreVirtualMembersCustomization());
fixture.Customizations.Add(new GlobalSettingsBuilder());
fixture.Customizations.Add(new EmergencyAccessBuilder());
fixture.Customizations.Add(new UserBuilder());
fixture.Customizations.Add(new EfRepositoryListBuilder<EmergencyAccessRepository>());
fixture.Customizations.Add(new EfRepositoryListBuilder<UserRepository>());
}
}
internal class EfEmergencyAccessAutoDataAttribute : CustomAutoDataAttribute
{
public EfEmergencyAccessAutoDataAttribute() : base(new SutProviderCustomization(), new EfEmergencyAccess())
{ }
}
internal class InlineEfEmergencyAccessAutoDataAttribute : InlineCustomAutoDataAttribute
{
public InlineEfEmergencyAccessAutoDataAttribute(params object[] values) : base(new[] { typeof(SutProviderCustomization),
typeof(EfEmergencyAccess) }, values)
{ }
}
}

119
test/Core.Test/AutoFixture/EntityFrameworkRepositoryFixtures.cs Normal file
View File

@ -0,0 +1,119 @@
using AutoFixture;
using AutoMapper;
using Bit.Core.Models.EntityFramework;
using System.Collections.Generic;
using AutoFixture.Kernel;
using System;
using Moq;
using Microsoft.Extensions.DependencyInjection;
using System.Reflection;
using Bit.Core.Repositories.EntityFramework;
using Bit.Core.Test.Helpers.Factories;
using Microsoft.EntityFrameworkCore;
using Bit.Core.Settings;
namespace Bit.Core.Test.AutoFixture.EntityFrameworkRepositoryFixtures
{
internal class ServiceScopeFactoryBuilder: ISpecimenBuilder
{
private DbContextOptions<DatabaseContext> _options { get; set; }
public ServiceScopeFactoryBuilder(DbContextOptions<DatabaseContext> options) {
_options = options;
}
public object Create(object request, ISpecimenContext context)
{
var fixture = new Fixture();
var serviceProvider = new Mock<IServiceProvider>();
var dbContext = new DatabaseContext(_options);
serviceProvider
.Setup(x => x.GetService(typeof(DatabaseContext)))
.Returns(dbContext);
var serviceScope = new Mock<IServiceScope>();
serviceScope.Setup(x => x.ServiceProvider).Returns(serviceProvider.Object);
var serviceScopeFactory = new Mock<IServiceScopeFactory>();
serviceScopeFactory
.Setup(x => x.CreateScope())
.Returns(serviceScope.Object);
return serviceScopeFactory.Object;
}
}
public class EfRepositoryListBuilder<T>: ISpecimenBuilder where T: BaseEntityFrameworkRepository
{
public object Create(object request, ISpecimenContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var t = request as ParameterInfo;
if (t == null || t.ParameterType != typeof(List<T>))
{
return new NoSpecimen();
}
var list = new List<T>();
foreach (var option in DatabaseOptionsFactory.Options)
{
var fixture = new Fixture();
fixture.Customize<IServiceScopeFactory>(x => x.FromFactory(new ServiceScopeFactoryBuilder(option)));
fixture.Customize<IMapper>(x => x.FromFactory(() =>
new MapperConfiguration(cfg => {
cfg.AddProfile<CipherMapperProfile>();
cfg.AddProfile<CollectionCipherMapperProfile>();
cfg.AddProfile<CollectionMapperProfile>();
cfg.AddProfile<DeviceMapperProfile>();
cfg.AddProfile<EmergencyAccessMapperProfile>();
cfg.AddProfile<EventMapperProfile>();
cfg.AddProfile<FolderMapperProfile>();
cfg.AddProfile<GrantMapperProfile>();
cfg.AddProfile<GroupMapperProfile>();
cfg.AddProfile<GroupUserMapperProfile>();
cfg.AddProfile<InstallationMapperProfile>();
cfg.AddProfile<OrganizationMapperProfile>();
cfg.AddProfile<OrganizationUserMapperProfile>();
cfg.AddProfile<PolicyMapperProfile>();
cfg.AddProfile<SendMapperProfile>();
cfg.AddProfile<SsoConfigMapperProfile>();
cfg.AddProfile<SsoUserMapperProfile>();
cfg.AddProfile<TaxRateMapperProfile>();
cfg.AddProfile<TransactionMapperProfile>();
cfg.AddProfile<U2fMapperProfile>();
cfg.AddProfile<UserMapperProfile>();
})
.CreateMapper()));
var repo = fixture.Create<T>();
list.Add(repo);
}
return list;
}
}
public class IgnoreVirtualMembersCustomization : ISpecimenBuilder
{
public object Create(object request, ISpecimenContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
var pi = request as PropertyInfo;
if (pi == null)
{
return new NoSpecimen();
}
if (pi.GetGetMethod().IsVirtual && pi.DeclaringType != typeof(GlobalSettings))
{
return null;
}
return new NoSpecimen();
}
}
}

65
test/Core.Test/AutoFixture/EventFixtures.cs Normal file
View File

@ -0,0 +1,65 @@
using AutoFixture;
using TableModel = Bit.Core.Models.Table;
using Bit.Core.Test.AutoFixture.Attributes;
using Bit.Core.Test.AutoFixture.GlobalSettingsFixtures;
using AutoMapper;
using Bit.Core.Models.EntityFramework;
using Bit.Core.Models;
using System.Collections.Generic;
using Bit.Core.Enums;
using AutoFixture.Kernel;
using System;
using Bit.Core.Test.AutoFixture.OrganizationFixtures;
using Bit.Core.Repositories.EntityFramework;
using Bit.Core.Test.AutoFixture.EntityFrameworkRepositoryFixtures;
using Bit.Core.Test.AutoFixture.Relays;
namespace Bit.Core.Test.AutoFixture.EventFixtures
{
internal class EventBuilder: ISpecimenBuilder
{
public object Create(object request, ISpecimenContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var type = request as Type;
if (type == null || type != typeof(TableModel.Event))
{
return new NoSpecimen();
}
var fixture = new Fixture();
fixture.Customizations.Insert(0, new MaxLengthStringRelay());
var obj = fixture.WithAutoNSubstitutions().Create<TableModel.Event>();
return obj;
}
}
internal class EfEvent: ICustomization
{
public void Customize(IFixture fixture)
{
fixture.Customizations.Add(new IgnoreVirtualMembersCustomization());
fixture.Customizations.Add(new GlobalSettingsBuilder());
fixture.Customizations.Add(new EventBuilder());
fixture.Customizations.Add(new EfRepositoryListBuilder<EventRepository>());
}
}
internal class EfEventAutoDataAttribute : CustomAutoDataAttribute
{
public EfEventAutoDataAttribute() : base(new SutProviderCustomization(), new EfEvent())
{ }
}
internal class InlineEfEventAutoDataAttribute : InlineCustomAutoDataAttribute
{
public InlineEfEventAutoDataAttribute(params object[] values) : base(new[] { typeof(SutProviderCustomization),
typeof(EfEvent) }, values)
{ }
}
}

68
test/Core.Test/AutoFixture/FolderFixtures.cs Normal file
View File

@ -0,0 +1,68 @@
using AutoFixture;
using TableModel = Bit.Core.Models.Table;
using Bit.Core.Test.AutoFixture.Attributes;
using Bit.Core.Test.AutoFixture.GlobalSettingsFixtures;
using AutoMapper;
using Bit.Core.Models.EntityFramework;
using Bit.Core.Models;
using System.Collections.Generic;
using Bit.Core.Enums;
using AutoFixture.Kernel;
using System;
using Bit.Core.Test.AutoFixture.OrganizationFixtures;
using Bit.Core.Repositories.EntityFramework;
using Bit.Core.Test.AutoFixture.EntityFrameworkRepositoryFixtures;
using Bit.Core.Test.AutoFixture.Relays;
using Bit.Core.Test.AutoFixture.UserFixtures;
namespace Bit.Core.Test.AutoFixture.FolderFixtures
{
internal class FolderBuilder: ISpecimenBuilder
{
public object Create(object request, ISpecimenContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var type = request as Type;
if (type == null || type != typeof(TableModel.Folder))
{
return new NoSpecimen();
}
var fixture = new Fixture();
fixture.Customizations.Insert(0, new MaxLengthStringRelay());
var obj = fixture.WithAutoNSubstitutions().Create<TableModel.Folder>();
return obj;
}
}
internal class EfFolder: ICustomization
{
public void Customize(IFixture fixture)
{
fixture.Customizations.Add(new IgnoreVirtualMembersCustomization());
fixture.Customizations.Add(new GlobalSettingsBuilder());
fixture.Customizations.Add(new FolderBuilder());
fixture.Customizations.Add(new UserBuilder());
fixture.Customizations.Add(new EfRepositoryListBuilder<FolderRepository>());
fixture.Customizations.Add(new EfRepositoryListBuilder<UserRepository>());
}
}
internal class EfFolderAutoDataAttribute : CustomAutoDataAttribute
{
public EfFolderAutoDataAttribute() : base(new SutProviderCustomization(), new EfFolder())
{ }
}
internal class InlineEfFolderAutoDataAttribute : InlineCustomAutoDataAttribute
{
public InlineEfFolderAutoDataAttribute(params object[] values) : base(new[] { typeof(SutProviderCustomization),
typeof(EfFolder) }, values)
{ }
}
}

34
test/Core.Test/AutoFixture/GlobalSettingsFixtures.cs
View File

@ -1,7 +1,37 @@
using AutoFixture;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;
using AutoFixture;
using AutoFixture.Kernel;
using AutoMapper;
using Bit.Core.Enums;
using Bit.Core.Models;
using Bit.Core.Models.Table;
using Bit.Core.Settings;
using Bit.Core.Test.Helpers.Factories;
namespace Bit.Core.Test.AutoFixture
namespace Bit.Core.Test.AutoFixture.GlobalSettingsFixtures
{
internal class GlobalSettingsBuilder: ISpecimenBuilder
{
public object Create(object request, ISpecimenContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var pi = request as ParameterInfo;
var fixture = new Fixture();
if (pi == null || pi.ParameterType != typeof(Settings.GlobalSettings))
return new NoSpecimen();
return GlobalSettingsFactory.GlobalSettings;
}
}
internal class GlobalSettings : ICustomization
{
public void Customize(IFixture fixture)

64
test/Core.Test/AutoFixture/GrantFixtures.cs Normal file
View File

@ -0,0 +1,64 @@
using AutoFixture;
using TableModel = Bit.Core.Models.Table;
using Bit.Core.Test.AutoFixture.Attributes;
using Bit.Core.Test.AutoFixture.GlobalSettingsFixtures;
using AutoMapper;
using Bit.Core.Models.EntityFramework;
using Bit.Core.Models;
using System.Collections.Generic;
using Bit.Core.Enums;
using AutoFixture.Kernel;
using System;
using Bit.Core.Test.AutoFixture.OrganizationFixtures;
using Bit.Core.Repositories.EntityFramework;
using Bit.Core.Test.AutoFixture.EntityFrameworkRepositoryFixtures;
using Bit.Core.Test.AutoFixture.Relays;
namespace Bit.Core.Test.AutoFixture.GrantFixtures
{
internal class GrantBuilder: ISpecimenBuilder
{
public object Create(object request, ISpecimenContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var type = request as Type;
if (type == null || type != typeof(TableModel.Grant))
{
return new NoSpecimen();
}
var fixture = new Fixture();
fixture.Customizations.Insert(0, new MaxLengthStringRelay());
var obj = fixture.WithAutoNSubstitutions().Create<TableModel.Grant>();
return obj;
}
}
internal class EfGrant: ICustomization
{
public void Customize(IFixture fixture)
{
fixture.Customizations.Add(new IgnoreVirtualMembersCustomization());
fixture.Customizations.Add(new GlobalSettingsBuilder());
fixture.Customizations.Add(new GrantBuilder());
fixture.Customizations.Add(new EfRepositoryListBuilder<GrantRepository>());
}
}
internal class EfGrantAutoDataAttribute : CustomAutoDataAttribute
{
public EfGrantAutoDataAttribute() : base(new SutProviderCustomization(), new EfGrant())
{ }
}
internal class InlineEfGrantAutoDataAttribute : InlineCustomAutoDataAttribute
{
public InlineEfGrantAutoDataAttribute(params object[] values) : base(new[] { typeof(SutProviderCustomization),
typeof(EfGrant) }, values)
{ }
}
}

65
test/Core.Test/AutoFixture/GroupFixtures.cs
View File

@ -1,19 +1,76 @@
using Bit.Core.Test.AutoFixture.Attributes;
using AutoFixture;
using TableModel = Bit.Core.Models.Table;
using Bit.Core.Test.AutoFixture.Attributes;
using Bit.Core.Test.AutoFixture.GlobalSettingsFixtures;
using AutoFixture.Kernel;
using System;
using Bit.Core.Test.AutoFixture.OrganizationFixtures;
using Bit.Core.Repositories.EntityFramework;
using Bit.Core.Test.AutoFixture.EntityFrameworkRepositoryFixtures;
using Bit.Core.Test.AutoFixture.Relays;
using Fixtures = Bit.Core.Test.AutoFixture.OrganizationFixtures;
namespace Bit.Core.Test.AutoFixture
namespace Bit.Core.Test.AutoFixture.GroupFixtures
{
internal class GroupOrganizationAutoDataAttribute : CustomAutoDataAttribute
{
public GroupOrganizationAutoDataAttribute() : base(
new SutProviderCustomization(), new Organization { UseGroups = true })
new SutProviderCustomization(), new Fixtures.Organization { UseGroups = true })
{ }
}
internal class GroupOrganizationNotUseGroupsAutoDataAttribute : CustomAutoDataAttribute
{
public GroupOrganizationNotUseGroupsAutoDataAttribute() : base(
new SutProviderCustomization(), new Organization { UseGroups = false })
new SutProviderCustomization(), new Bit.Core.Test.AutoFixture.OrganizationFixtures.Organization { UseGroups = false })
{ }
}
internal class GroupBuilder: ISpecimenBuilder
{
public object Create(object request, ISpecimenContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var type = request as Type;
if (type == null || type != typeof(TableModel.Group))
{
return new NoSpecimen();
}
var fixture = new Fixture();
fixture.Customizations.Insert(0, new MaxLengthStringRelay());
var obj = fixture.WithAutoNSubstitutions().Create<TableModel.Group>();
return obj;
}
}
internal class EfGroup: ICustomization
{
public void Customize(IFixture fixture)
{
fixture.Customizations.Add(new IgnoreVirtualMembersCustomization());
fixture.Customizations.Add(new GlobalSettingsBuilder());
fixture.Customizations.Add(new GroupBuilder());
fixture.Customizations.Add(new OrganizationBuilder());
fixture.Customizations.Add(new EfRepositoryListBuilder<GroupRepository>());
fixture.Customizations.Add(new EfRepositoryListBuilder<OrganizationRepository>());
}
}
internal class EfGroupAutoDataAttribute : CustomAutoDataAttribute
{
public EfGroupAutoDataAttribute() : base(new SutProviderCustomization(), new EfGroup())
{ }
}
internal class InlineEfGroupAutoDataAttribute : InlineCustomAutoDataAttribute
{
public InlineEfGroupAutoDataAttribute(params object[] values) : base(new[] { typeof(SutProviderCustomization),
typeof(EfGroup) }, values)
{ }
}
}

63
test/Core.Test/AutoFixture/GroupUserFixtures.cs Normal file
View File

@ -0,0 +1,63 @@
using AutoFixture;
using TableModel = Bit.Core.Models.Table;
using Bit.Core.Test.AutoFixture.Attributes;
using Bit.Core.Test.AutoFixture.GlobalSettingsFixtures;
using AutoMapper;
using Bit.Core.Models.EntityFramework;
using Bit.Core.Models;
using System.Collections.Generic;
using Bit.Core.Enums;
using AutoFixture.Kernel;
using System;
using Bit.Core.Test.AutoFixture.OrganizationFixtures;
using Bit.Core.Repositories.EntityFramework;
using Bit.Core.Test.AutoFixture.EntityFrameworkRepositoryFixtures;
namespace Bit.Core.Test.AutoFixture.GroupUserFixtures
{
internal class GroupUserBuilder: ISpecimenBuilder
{
public object Create(object request, ISpecimenContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var type = request as Type;
if (type == null || type != typeof(TableModel.GroupUser))
{
return new NoSpecimen();
}
var fixture = new Fixture();
var obj = fixture.WithAutoNSubstitutions().Create<TableModel.GroupUser>();
return obj;
}
}
internal class EfGroupUser: ICustomization
{
public void Customize(IFixture fixture)
{
fixture.Customizations.Add(new IgnoreVirtualMembersCustomization());
fixture.Customizations.Add(new GlobalSettingsBuilder());
fixture.Customizations.Add(new GroupUserBuilder());
fixture.Customizations.Add(new EfRepositoryListBuilder<GroupRepository>());
}
}
internal class EfGroupUserAutoDataAttribute : CustomAutoDataAttribute
{
public EfGroupUserAutoDataAttribute() : base(new SutProviderCustomization(), new EfGroupUser())
{ }
}
internal class InlineEfGroupUserAutoDataAttribute : InlineCustomAutoDataAttribute
{
public InlineEfGroupUserAutoDataAttribute(params object[] values) : base(new[] { typeof(SutProviderCustomization),
typeof(EfGroupUser) }, values)
{ }
}
}

63
test/Core.Test/AutoFixture/InstallationFixtures.cs Normal file
View File

@ -0,0 +1,63 @@
using AutoFixture;
using TableModel = Bit.Core.Models.Table;
using Bit.Core.Test.AutoFixture.Attributes;
using Bit.Core.Test.AutoFixture.GlobalSettingsFixtures;
using AutoMapper;
using Bit.Core.Models.EntityFramework;
using Bit.Core.Models;
using System.Collections.Generic;
using Bit.Core.Enums;
using AutoFixture.Kernel;
using System;
using Bit.Core.Test.AutoFixture.OrganizationFixtures;
using Bit.Core.Repositories.EntityFramework;
using Bit.Core.Test.AutoFixture.EntityFrameworkRepositoryFixtures;
namespace Bit.Core.Test.AutoFixture.InstallationFixtures
{
internal class InstallationBuilder: ISpecimenBuilder
{
public object Create(object request, ISpecimenContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var type = request as Type;
if (type == null || type != typeof(TableModel.Installation))
{
return new NoSpecimen();
}
var fixture = new Fixture();
var obj = fixture.WithAutoNSubstitutions().Create<TableModel.Installation>();
return obj;
}
}
internal class EfInstallation: ICustomization
{
public void Customize(IFixture fixture)
{
fixture.Customizations.Add(new IgnoreVirtualMembersCustomization());
fixture.Customizations.Add(new GlobalSettingsBuilder());
fixture.Customizations.Add(new InstallationBuilder());
fixture.Customizations.Add(new EfRepositoryListBuilder<InstallationRepository>());
}
}
internal class EfInstallationAutoDataAttribute : CustomAutoDataAttribute
{
public EfInstallationAutoDataAttribute() : base(new SutProviderCustomization(), new EfInstallation())
{ }
}
internal class InlineEfInstallationAutoDataAttribute : InlineCustomAutoDataAttribute
{
public InlineEfInstallationAutoDataAttribute(params object[] values) : base(new[] { typeof(SutProviderCustomization),
typeof(EfInstallation) }, values)
{ }
}
}

61
test/Core.Test/AutoFixture/OrganizationFixtures.cs
View File

@ -6,9 +6,14 @@ using AutoFixture;
using Bit.Core.Enums;
using Bit.Core.Models.Business;
using Bit.Core.Models.Data;
using Bit.Core.Models.Table;
using TableModel = Bit.Core.Models.Table;
using Bit.Core.Test.AutoFixture.Attributes;
using Bit.Core.Test.AutoFixture.GlobalSettingsFixtures;
using Bit.Core.Utilities;
using AutoFixture.Kernel;
using Bit.Core.Models;
using Bit.Core.Test.AutoFixture.EntityFrameworkRepositoryFixtures;
using Bit.Core.Repositories.EntityFramework;
namespace Bit.Core.Test.AutoFixture.OrganizationFixtures
{
@ -30,7 +35,30 @@ namespace Bit.Core.Test.AutoFixture.OrganizationFixtures
composer
.With(c => c.OrganizationId, organizationId));
fixture.Customize<Group>(composer => composer.With(g => g.OrganizationId, organizationId));
fixture.Customize<TableModel.Group>(composer => composer.With(g => g.OrganizationId, organizationId));
}
}
internal class OrganizationBuilder: ISpecimenBuilder
{
public object Create(object request, ISpecimenContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var type = request as Type;
if (type == null || type != typeof(TableModel.Organization))
{
return new NoSpecimen();
}
var fixture = new Fixture();
var providers = fixture.Create<Dictionary<TwoFactorProviderType, TwoFactorProvider>>();
var organization = new Fixture().WithAutoNSubstitutions().Create<TableModel.Organization>();
organization.SetTwoFactorProviders(providers);
return organization;
}
}
@ -46,7 +74,7 @@ namespace Bit.Core.Test.AutoFixture.OrganizationFixtures
fixture.Customize<Core.Models.Table.Organization>(composer => composer
.With(o => o.PlanType, CheckedPlanType));
fixture.Customize<OrganizationUpgrade>(composer => composer
.With(ou => ou.Plan, validUpgradePlans.First()));
.With(ou => ou.Plan, validUpgradePlans.First())) ;
}
}
@ -67,6 +95,7 @@ namespace Bit.Core.Test.AutoFixture.OrganizationFixtures
.Without(o => o.GatewaySubscriptionId));
}
}
internal class OrganizationInvite : ICustomization
{
public OrganizationUserType InviteeUserType { get; set; }
@ -82,7 +111,7 @@ namespace Bit.Core.Test.AutoFixture.OrganizationFixtures
fixture.Customize<Core.Models.Table.Organization>(composer => composer
.With(o => o.Id, organizationId)
.With(o => o.Seats, (short)100));
fixture.Customize<OrganizationUser>(composer => composer
fixture.Customize<TableModel.OrganizationUser>(composer => composer
.With(ou => ou.OrganizationId, organizationId)
.With(ou => ou.Type, InvitorUserType)
.With(ou => ou.Permissions, PermissionsBlob));
@ -91,6 +120,17 @@ namespace Bit.Core.Test.AutoFixture.OrganizationFixtures
}
}
internal class EfOrganization: ICustomization
{
public void Customize(IFixture fixture)
{
fixture.Customizations.Add(new IgnoreVirtualMembersCustomization());
fixture.Customizations.Add(new GlobalSettingsBuilder());
fixture.Customizations.Add(new OrganizationBuilder());
fixture.Customizations.Add(new EfRepositoryListBuilder<OrganizationRepository>());
}
}
internal class PaidOrganizationAutoDataAttribute : CustomAutoDataAttribute
{
public PaidOrganizationAutoDataAttribute(int planType = 0) : base(new SutProviderCustomization(),
@ -136,4 +176,17 @@ namespace Bit.Core.Test.AutoFixture.OrganizationFixtures
typeof(OrganizationInvite) }, values)
{ }
}
internal class EfOrganizationAutoDataAttribute : CustomAutoDataAttribute
{
public EfOrganizationAutoDataAttribute() : base(new SutProviderCustomization(), new EfOrganization())
{ }
}
internal class InlineEfOrganizationAutoDataAttribute : InlineCustomAutoDataAttribute
{
public InlineEfOrganizationAutoDataAttribute(params object[] values) : base(new[] { typeof(SutProviderCustomization),
typeof(EfOrganization) }, values)
{ }
}
}

87
test/Core.Test/AutoFixture/OrganizationUserFixtures.cs
View File

@ -1,10 +1,63 @@
using System.Reflection;
using AutoFixture;
using AutoFixture.Xunit2;
using AutoFixture;
using TableModel = Bit.Core.Models.Table;
using Bit.Core.Test.AutoFixture.Attributes;
using Bit.Core.Test.AutoFixture.GlobalSettingsFixtures;
using AutoMapper;
using Bit.Core.Models.EntityFramework;
using Bit.Core.Models;
using System.Collections.Generic;
using Bit.Core.Enums;
using AutoFixture.Kernel;
using System;
using Bit.Core.Test.AutoFixture.OrganizationFixtures;
using Bit.Core.Repositories.EntityFramework;
using Bit.Core.Test.AutoFixture.EntityFrameworkRepositoryFixtures;
using Bit.Core.Models.Data;
using System.Text.Json;
using Bit.Core.Test.AutoFixture.UserFixtures;
using AutoFixture.Xunit2;
using System.Reflection;
namespace Bit.Core.Test.AutoFixture.OrganizationUserFixtures
{
internal class OrganizationUserBuilder: ISpecimenBuilder
{
public object Create(object request, ISpecimenContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var type = request as Type;
if (type == typeof(OrganizationUser))
{
var fixture = new Fixture();
var orgUser = fixture.WithAutoNSubstitutions().Create<TableModel.OrganizationUser>();
var orgUserPermissions = fixture.WithAutoNSubstitutions().Create<Permissions>();
orgUser.Permissions = JsonSerializer.Serialize(orgUserPermissions, new JsonSerializerOptions() {
PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
});
return orgUser;
}
else if (type == typeof(List<OrganizationUser>))
{
var fixture = new Fixture();
var orgUsers = fixture.WithAutoNSubstitutions().CreateMany<TableModel.OrganizationUser>(2);
foreach (var orgUser in orgUsers)
{
var providers = fixture.Create<Dictionary<TwoFactorProviderType, TwoFactorProvider>>();
var orgUserPermissions = fixture.WithAutoNSubstitutions().Create<Permissions>();
orgUser.Permissions = JsonSerializer.Serialize(orgUserPermissions, new JsonSerializerOptions() {
PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
});
}
return orgUsers;
}
return new NoSpecimen();
}
}
internal class OrganizationUser : ICustomization
{
public OrganizationUserStatusType Status { get; set; }
@ -42,4 +95,32 @@ namespace Bit.Core.Test.AutoFixture.OrganizationUserFixtures
return new OrganizationUser(_status, _type);
}
}
internal class EfOrganizationUser: ICustomization
{
public void Customize(IFixture fixture)
{
fixture.Customizations.Add(new IgnoreVirtualMembersCustomization());
fixture.Customizations.Add(new GlobalSettingsBuilder());
fixture.Customizations.Add(new OrganizationUserBuilder());
fixture.Customizations.Add(new OrganizationBuilder());
fixture.Customizations.Add(new UserBuilder());
fixture.Customizations.Add(new EfRepositoryListBuilder<OrganizationUserRepository>());
fixture.Customizations.Add(new EfRepositoryListBuilder<UserRepository>());
fixture.Customizations.Add(new EfRepositoryListBuilder<OrganizationRepository>());
}
}
internal class EfOrganizationUserAutoDataAttribute : CustomAutoDataAttribute
{
public EfOrganizationUserAutoDataAttribute() : base(new SutProviderCustomization(), new EfOrganizationUser())
{ }
}
internal class InlineEfOrganizationUserAutoDataAttribute : InlineCustomAutoDataAttribute
{
public InlineEfOrganizationUserAutoDataAttribute(params object[] values) : base(new[] { typeof(SutProviderCustomization),
typeof(EfOrganizationUser) }, values)
{ }
}
}

64
test/Core.Test/AutoFixture/PolicyFixtures.cs
View File

@ -1,10 +1,23 @@
using System;
using System.Reflection;
using AutoFixture;
using AutoFixture.Xunit2;
using TableModel = Bit.Core.Models.Table;
using Bit.Core.Test.AutoFixture.Attributes;
using Bit.Core.Test.AutoFixture.GlobalSettingsFixtures;
using AutoMapper;
using Bit.Core.Models.EntityFramework;
using Bit.Core.Models;
using System.Collections.Generic;
using Bit.Core.Enums;
using AutoFixture.Kernel;
using System;
using Bit.Core.Test.AutoFixture.OrganizationFixtures;
using Bit.Core.Repositories.EntityFramework;
using Bit.Core.Test.AutoFixture.EntityFrameworkRepositoryFixtures;
using System.Reflection;
using AutoFixture.Xunit2;
namespace Bit.Core.Test.AutoFixture.OrganizationUserFixtures
namespace Bit.Core.Test.AutoFixture.PolicyFixtures
{
internal class Policy : ICustomization
{
@ -38,4 +51,51 @@ namespace Bit.Core.Test.AutoFixture.OrganizationUserFixtures
return new Policy(_type);
}
}
internal class PolicyBuilder: ISpecimenBuilder
{
public object Create(object request, ISpecimenContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var type = request as Type;
if (type == null || type != typeof(TableModel.Policy))
{
return new NoSpecimen();
}
var fixture = new Fixture();
var obj = fixture.WithAutoNSubstitutions().Create<TableModel.Policy>();
return obj;
}
}
internal class EfPolicy: ICustomization
{
public void Customize(IFixture fixture)
{
fixture.Customizations.Add(new IgnoreVirtualMembersCustomization());
fixture.Customizations.Add(new GlobalSettingsBuilder());
fixture.Customizations.Add(new PolicyBuilder());
fixture.Customizations.Add(new OrganizationBuilder());
fixture.Customizations.Add(new EfRepositoryListBuilder<PolicyRepository>());
fixture.Customizations.Add(new EfRepositoryListBuilder<OrganizationRepository>());
}
}
internal class EfPolicyAutoDataAttribute : CustomAutoDataAttribute
{
public EfPolicyAutoDataAttribute() : base(new SutProviderCustomization(), new EfPolicy())
{ }
}
internal class InlineEfPolicyAutoDataAttribute : InlineCustomAutoDataAttribute
{
public InlineEfPolicyAutoDataAttribute(params object[] values) : base(new[] { typeof(SutProviderCustomization),
typeof(EfPolicy) }, values)
{ }
}
}

43
test/Core.Test/AutoFixture/Relays/MaxLengthStringRelay.cs Normal file
View File

@ -0,0 +1,43 @@
using AutoFixture.Kernel;
using System;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Reflection;
namespace Bit.Core.Test.AutoFixture.Relays
{
// Creates a string the same length as any availible MaxLength data annotation
// Modified version of the StringLenfthRelay provided by AutoFixture
// https://github.com/AutoFixture/AutoFixture/blob/master/Src/AutoFixture/DataAnnotations/StringLengthAttributeRelay.cs
internal class MaxLengthStringRelay: ISpecimenBuilder
{
public object Create(object request, ISpecimenContext context)
{
if (request == null)
{
return new NoSpecimen();
}
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var p = request as PropertyInfo;
if (p == null)
{
return new NoSpecimen();
}
var a = (MaxLengthAttribute)p.GetCustomAttributes(typeof(MaxLengthAttribute), false).SingleOrDefault();
if (a == null)
{
return new NoSpecimen();
}
return context.Resolve(new ConstrainedStringRequest(a.Length, a.Length));
}
}
}

65
test/Core.Test/AutoFixture/SendFixtures.cs
View File

@ -1,7 +1,14 @@
using System;
using AutoFixture;
using AutoFixture.Kernel;
using Bit.Core.Models.Table;
using Bit.Core.Repositories.EntityFramework;
using Bit.Core.Test.AutoFixture.Attributes;
using Bit.Core.Test.AutoFixture.EntityFrameworkRepositoryFixtures;
using Bit.Core.Test.AutoFixture.GlobalSettingsFixtures;
using Bit.Core.Test.AutoFixture.OrganizationFixtures;
using Bit.Core.Test.AutoFixture.Relays;
using Bit.Core.Test.AutoFixture.UserFixtures;
namespace Bit.Core.Test.AutoFixture.SendFixtures
{
@ -62,4 +69,62 @@ namespace Bit.Core.Test.AutoFixture.SendFixtures
typeof(SutProviderCustomization), typeof(OrganizationSend) }, values)
{ }
}
internal class SendBuilder: ISpecimenBuilder
{
public bool OrganizationOwned { get; set; }
public object Create(object request, ISpecimenContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var type = request as Type;
if (type == null || type != typeof(Send))
{
return new NoSpecimen();
}
var fixture = new Fixture();
fixture.Customizations.Insert(0, new MaxLengthStringRelay());
if (!OrganizationOwned)
{
fixture.Customize<Send>(composer => composer
.Without(c => c.OrganizationId));
}
var obj = fixture.WithAutoNSubstitutions().Create<Send>();
return obj;
}
}
internal class EfSend: ICustomization
{
public bool OrganizationOwned { get; set; }
public void Customize(IFixture fixture)
{
fixture.Customizations.Add(new IgnoreVirtualMembersCustomization());
fixture.Customizations.Add(new GlobalSettingsBuilder());
fixture.Customizations.Add(new SendBuilder());
fixture.Customizations.Add(new UserBuilder());
fixture.Customizations.Add(new OrganizationBuilder());
fixture.Customizations.Add(new EfRepositoryListBuilder<SendRepository>());
fixture.Customizations.Add(new EfRepositoryListBuilder<UserRepository>());
fixture.Customizations.Add(new EfRepositoryListBuilder<OrganizationRepository>());
}
}
internal class EfUserSendAutoDataAttribute : CustomAutoDataAttribute
{
public EfUserSendAutoDataAttribute() : base(new SutProviderCustomization(), new EfSend())
{ }
}
internal class EfOrganizationSendAutoDataAttribute : CustomAutoDataAttribute
{
public EfOrganizationSendAutoDataAttribute() : base(new SutProviderCustomization(), new EfSend(){
OrganizationOwned = true,
})
{ }
}
}

67
test/Core.Test/AutoFixture/SsoConfigFixtures.cs Normal file
View File

@ -0,0 +1,67 @@
using System;
using AutoFixture;
using AutoFixture.Kernel;
using AutoMapper;
using TableModel = Bit.Core.Models.Table;
using Bit.Core.Models.EntityFramework;
using Bit.Core.Test.AutoFixture.Attributes;
using Bit.Core.Test.AutoFixture.GlobalSettingsFixtures;
using Bit.Core.Test.AutoFixture.OrganizationFixtures;
using Bit.Core.Models.Data;
using System.Text.Json;
using Bit.Core.Test.AutoFixture.EntityFrameworkRepositoryFixtures;
using Bit.Core.Repositories.EntityFramework;
namespace Bit.Core.Test.AutoFixture.SsoConfigFixtures
{
internal class SsoConfigBuilder: ISpecimenBuilder
{
public object Create(object request, ISpecimenContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var type = request as Type;
if (type == null || type != typeof(TableModel.SsoConfig))
{
return new NoSpecimen();
}
var fixture = new Fixture();
var ssoConfig = fixture.WithAutoNSubstitutions().Create<TableModel.SsoConfig>();
var ssoConfigData = fixture.WithAutoNSubstitutions().Create<SsoConfigurationData>();
ssoConfig.Data = JsonSerializer.Serialize(ssoConfigData, new JsonSerializerOptions(){
PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
});
return ssoConfig;
}
}
internal class EfSsoConfig: ICustomization
{
public void Customize(IFixture fixture)
{
fixture.Customizations.Add(new IgnoreVirtualMembersCustomization());
fixture.Customizations.Add(new GlobalSettingsBuilder());
fixture.Customizations.Add(new OrganizationBuilder());
fixture.Customizations.Add(new SsoConfigBuilder());
fixture.Customizations.Add(new EfRepositoryListBuilder<SsoConfigRepository>());
fixture.Customizations.Add(new EfRepositoryListBuilder<OrganizationRepository>());
}
}
internal class EfSsoConfigAutoDataAttribute : CustomAutoDataAttribute
{
public EfSsoConfigAutoDataAttribute() : base(new SutProviderCustomization(), new EfSsoConfig())
{ }
}
internal class InlineEfSsoConfigAutoDataAttribute : InlineCustomAutoDataAttribute
{
public InlineEfSsoConfigAutoDataAttribute(params object[] values) : base(new[] { typeof(SutProviderCustomization),
typeof(EfSsoConfig) }, values)
{ }
}
}

41
test/Core.Test/AutoFixture/SsoUserFixtures.cs Normal file
View File

@ -0,0 +1,41 @@
using AutoFixture;
using AutoMapper;
using Bit.Core.Models.EntityFramework;
using Bit.Core.Repositories.EntityFramework;
using Bit.Core.Test.AutoFixture.Attributes;
using Bit.Core.Test.AutoFixture.EntityFrameworkRepositoryFixtures;
using Bit.Core.Test.AutoFixture.GlobalSettingsFixtures;
using Bit.Core.Test.AutoFixture.OrganizationFixtures;
using Bit.Core.Test.AutoFixture.UserFixtures;
using TableModel = Bit.Core.Models.Table;
namespace Bit.Core.Test.AutoFixture.SsoUserFixtures
{
internal class EfSsoUser: ICustomization
{
public void Customize(IFixture fixture)
{
fixture.Customizations.Add(new IgnoreVirtualMembersCustomization());
fixture.Customizations.Add(new GlobalSettingsBuilder());
fixture.Customizations.Add(new UserBuilder());
fixture.Customizations.Add(new OrganizationBuilder());
fixture.Customize<TableModel.SsoUser>(composer => composer.Without(ou => ou.Id));
fixture.Customizations.Add(new EfRepositoryListBuilder<SsoUserRepository>());
fixture.Customizations.Add(new EfRepositoryListBuilder<UserRepository>());
fixture.Customizations.Add(new EfRepositoryListBuilder<OrganizationRepository>());
}
}
internal class EfSsoUserAutoDataAttribute : CustomAutoDataAttribute
{
public EfSsoUserAutoDataAttribute() : base(new SutProviderCustomization(), new EfSsoUser())
{ }
}
internal class InlineEfSsoUserAutoDataAttribute : InlineCustomAutoDataAttribute
{
public InlineEfSsoUserAutoDataAttribute(params object[] values) : base(new[] { typeof(SutProviderCustomization),
typeof(EfSsoUser) }, values)
{ }
}
}

1
test/Core.Test/AutoFixture/SutProvider.cs
View File

@ -4,6 +4,7 @@ using AutoFixture;
using AutoFixture.Kernel;
using System.Reflection;
using System.Linq;
using Bit.Core.Test.AutoFixture.GlobalSettingsFixtures;
namespace Bit.Core.Test.AutoFixture
{

65
test/Core.Test/AutoFixture/TaxRateFixtures.cs Normal file
View File

@ -0,0 +1,65 @@
using AutoFixture;
using TableModel = Bit.Core.Models.Table;
using Bit.Core.Test.AutoFixture.Attributes;
using Bit.Core.Test.AutoFixture.GlobalSettingsFixtures;
using AutoMapper;
using Bit.Core.Models.EntityFramework;
using Bit.Core.Models;
using System.Collections.Generic;
using Bit.Core.Enums;
using AutoFixture.Kernel;
using System;
using Bit.Core.Test.AutoFixture.OrganizationFixtures;
using Bit.Core.Repositories.EntityFramework;
using Bit.Core.Test.AutoFixture.EntityFrameworkRepositoryFixtures;
using Bit.Core.Test.AutoFixture.Relays;
namespace Bit.Core.Test.AutoFixture.TaxRateFixtures
{
internal class TaxRateBuilder: ISpecimenBuilder
{
public object Create(object request, ISpecimenContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var type = request as Type;
if (type == null || type != typeof(TableModel.TaxRate))
{
return new NoSpecimen();
}
var fixture = new Fixture();
fixture.Customizations.Insert(0, new MaxLengthStringRelay());
var obj = fixture.WithAutoNSubstitutions().Create<TableModel.TaxRate>();
return obj;
}
}
internal class EfTaxRate: ICustomization
{
public void Customize(IFixture fixture)
{
fixture.Customizations.Add(new IgnoreVirtualMembersCustomization());
fixture.Customizations.Add(new GlobalSettingsBuilder());
fixture.Customizations.Add(new TaxRateBuilder());
fixture.Customizations.Add(new EfRepositoryListBuilder<TaxRateRepository>());
}
}
internal class EfTaxRateAutoDataAttribute : CustomAutoDataAttribute
{
public EfTaxRateAutoDataAttribute() : base(new SutProviderCustomization(), new EfTaxRate())
{ }
}
internal class InlineEfTaxRateAutoDataAttribute : InlineCustomAutoDataAttribute
{
public InlineEfTaxRateAutoDataAttribute(params object[] values) : base(new[] { typeof(SutProviderCustomization),
typeof(EfTaxRate) }, values)
{ }
}
}

78
test/Core.Test/AutoFixture/TransactionFixutres.cs Normal file
View File

@ -0,0 +1,78 @@
using AutoFixture;
using TableModel = Bit.Core.Models.Table;
using Bit.Core.Test.AutoFixture.Attributes;
using Bit.Core.Test.AutoFixture.GlobalSettingsFixtures;
using AutoMapper;
using Bit.Core.Models.EntityFramework;
using Bit.Core.Models;
using System.Collections.Generic;
using Bit.Core.Enums;
using AutoFixture.Kernel;
using System;
using Bit.Core.Test.AutoFixture.OrganizationFixtures;
using Bit.Core.Repositories.EntityFramework;
using Bit.Core.Test.AutoFixture.EntityFrameworkRepositoryFixtures;
using Bit.Core.Test.AutoFixture.UserFixtures;
using Bit.Core.Test.AutoFixture.Relays;
namespace Bit.Core.Test.AutoFixture.TransactionFixtures
{
internal class TransactionBuilder: ISpecimenBuilder
{
public bool OrganizationOwned { get; set; }
public object Create(object request, ISpecimenContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var type = request as Type;
if (type == null || type != typeof(TableModel.Transaction))
{
return new NoSpecimen();
}
var fixture = new Fixture();
if (!OrganizationOwned)
{
fixture.Customize<Transaction>(composer => composer
.Without(c => c.OrganizationId));
}
fixture.Customizations.Add(new MaxLengthStringRelay());
var obj = fixture.WithAutoNSubstitutions().Create<TableModel.Transaction>();
return obj;
}
}
internal class EfTransaction: ICustomization
{
public bool OrganizationOwned { get; set; }
public void Customize(IFixture fixture)
{
fixture.Customizations.Add(new IgnoreVirtualMembersCustomization());
fixture.Customizations.Add(new GlobalSettingsBuilder());
fixture.Customizations.Add(new TransactionBuilder());
fixture.Customizations.Add(new UserBuilder());
fixture.Customizations.Add(new OrganizationBuilder());
fixture.Customizations.Add(new EfRepositoryListBuilder<TransactionRepository>());
fixture.Customizations.Add(new EfRepositoryListBuilder<UserRepository>());
fixture.Customizations.Add(new EfRepositoryListBuilder<OrganizationRepository>());
}
}
internal class EfUserTransactionAutoDataAttribute : CustomAutoDataAttribute
{
public EfUserTransactionAutoDataAttribute() : base(new SutProviderCustomization(), new EfTransaction())
{ }
}
internal class EfOrganizationTransactionAutoDataAttribute : CustomAutoDataAttribute
{
public EfOrganizationTransactionAutoDataAttribute() : base(new SutProviderCustomization(), new EfTransaction(){
OrganizationOwned = true,
})
{ }
}
}

68
test/Core.Test/AutoFixture/U2fFixtures.cs Normal file
View File

@ -0,0 +1,68 @@
using AutoFixture;
using TableModel = Bit.Core.Models.Table;
using Bit.Core.Test.AutoFixture.Attributes;
using Bit.Core.Test.AutoFixture.GlobalSettingsFixtures;
using AutoMapper;
using Bit.Core.Models.EntityFramework;
using Bit.Core.Models;
using System.Collections.Generic;
using Bit.Core.Enums;
using AutoFixture.Kernel;
using System;
using Bit.Core.Test.AutoFixture.OrganizationFixtures;
using Bit.Core.Repositories.EntityFramework;
using Bit.Core.Test.AutoFixture.EntityFrameworkRepositoryFixtures;
using Bit.Core.Test.AutoFixture.Relays;
using Bit.Core.Test.AutoFixture.UserFixtures;
namespace Bit.Core.Test.AutoFixture.U2fFixtures
{
internal class U2fBuilder: ISpecimenBuilder
{
public object Create(object request, ISpecimenContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var type = request as Type;
if (type == null || type != typeof(TableModel.U2f))
{
return new NoSpecimen();
}
var fixture = new Fixture();
fixture.Customizations.Add(new MaxLengthStringRelay());
var obj = fixture.WithAutoNSubstitutions().Create<TableModel.U2f>();
return obj;
}
}
internal class EfU2f: ICustomization
{
public void Customize(IFixture fixture)
{
fixture.Customizations.Add(new IgnoreVirtualMembersCustomization());
fixture.Customizations.Add(new GlobalSettingsBuilder());
fixture.Customizations.Add(new U2fBuilder());
fixture.Customizations.Add(new UserBuilder());
fixture.Customizations.Add(new EfRepositoryListBuilder<U2fRepository>());
fixture.Customizations.Add(new EfRepositoryListBuilder<UserRepository>());
}
}
internal class EfU2fAutoDataAttribute : CustomAutoDataAttribute
{
public EfU2fAutoDataAttribute() : base(new SutProviderCustomization(), new EfU2f())
{ }
}
internal class InlineEfU2fAutoDataAttribute : InlineCustomAutoDataAttribute
{
public InlineEfU2fAutoDataAttribute(params object[] values) : base(new[] { typeof(SutProviderCustomization),
typeof(EfU2f) }, values)
{ }
}
}

78
test/Core.Test/AutoFixture/UserFixtures.cs Normal file
View File

@ -0,0 +1,78 @@
using AutoFixture;
using TableModel = Bit.Core.Models.Table;
using Bit.Core.Test.AutoFixture.Attributes;
using Bit.Core.Test.AutoFixture.GlobalSettingsFixtures;
using AutoMapper;
using Bit.Core.Models.EntityFramework;
using Bit.Core.Models;
using System.Collections.Generic;
using Bit.Core.Enums;
using AutoFixture.Kernel;
using System;
using Bit.Core.Test.AutoFixture.OrganizationFixtures;
using Bit.Core.Repositories.EntityFramework;
using Bit.Core.Test.AutoFixture.EntityFrameworkRepositoryFixtures;
namespace Bit.Core.Test.AutoFixture.UserFixtures
{
internal class UserBuilder: ISpecimenBuilder
{
public object Create(object request, ISpecimenContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var type = request as Type;
if (type == typeof(TableModel.User))
{
var fixture = new Fixture();
var providers = fixture.Create<Dictionary<TwoFactorProviderType, TwoFactorProvider>>();
var user = fixture.WithAutoNSubstitutions().Create<TableModel.User>();
user.SetTwoFactorProviders(providers);
return user;
}
else if (type == typeof(List<TableModel.User>))
{
var fixture = new Fixture();
var users = fixture.WithAutoNSubstitutions().CreateMany<TableModel.User>(2);
foreach (var user in users)
{
var providers = fixture.Create<Dictionary<TwoFactorProviderType, TwoFactorProvider>>();
user.SetTwoFactorProviders(providers);
}
return users;
}
return new NoSpecimen();
}
}
internal class EfUser: ICustomization
{
public void Customize(IFixture fixture)
{
fixture.Customizations.Add(new IgnoreVirtualMembersCustomization());
fixture.Customizations.Add(new GlobalSettingsBuilder());
fixture.Customizations.Add(new UserBuilder());
fixture.Customizations.Add(new OrganizationBuilder());
fixture.Customizations.Add(new EfRepositoryListBuilder<UserRepository>());
fixture.Customizations.Add(new EfRepositoryListBuilder<SsoUserRepository>());
fixture.Customizations.Add(new EfRepositoryListBuilder<OrganizationRepository>());
}
}
internal class EfUserAutoDataAttribute : CustomAutoDataAttribute
{
public EfUserAutoDataAttribute() : base(new SutProviderCustomization(), new EfUser())
{ }
}
internal class InlineEfUserAutoDataAttribute : InlineCustomAutoDataAttribute
{
public InlineEfUserAutoDataAttribute(params object[] values) : base(new[] { typeof(SutProviderCustomization),
typeof(EfUser) }, values)
{ }
}
}