public TenantStoreTests()
{
// Configure connection strings per tenant
var connStr = new List <KeyValuePair <string, string> >();
_tenantNames.ForEach(t => connStr.Add(new KeyValuePair <string, string>($"{ConnectionStrings}:{ConnKeyPrefix}{t}", $"{ConnValuePrefix}{t}")));
// Build configuration
var cb = new ConfigurationBuilder();
cb.AddInMemoryCollection(connStr);
var config = cb.Build();
// Create the mocked store with only 1 method setup for moq
var tenantStoreMock = new Mock <TenantStore>(config, new NullLogger <TenantStore>());
tenantStoreMock.CallBase = true; // IMPORTANT if original methods shall be used
// Just override one method:
tenantStoreMock.Setup(s => s.ReadTenantConfigFile(It.IsAny <string>())).Returns((string tenantName) =>
{
var tenant = new TenantContext
{
Identifier = tenantName,
IsDefault = tenantName.Equals("DefaultTenant"),
Guid = Guid.NewGuid(),
Filename = tenantName,
SiteContext = { UrlSegmentValue = tenantName },
DbContext = { ConnectionKey = ConnKeyPrefix + tenantName },
OrganizationContext = { Name = "Long: " + tenantName, ShortName = "Short: " + tenantName }
};
return(tenant.Serialize());
});
tenantStoreMock.Setup(s => s.LoadTenants());
_store = tenantStoreMock.Object;
_store.GetTenantConfigurationFiles = () => _tenantNames.ToArray();
}
public async Task OnPostAsync()
{
if (Input.Name.IsNullOrEmpty())
{
Response.Cookies.Delete(Options.TenantKey);
}
else
{
var tenant = await TenantStore.FindAsync(Input.Name);
if (tenant == null)
{
throw new UserFriendlyException(L["GivenTenantIsNotAvailable", Input.Name]);
}
Response.Cookies.Append(
Options.TenantKey,
tenant.Id.ToString(),
new CookieOptions
{
Path = "/",
HttpOnly = false,
Expires = DateTimeOffset.Now.AddYears(10)
}
);
}
}
private void ConfigureLlblgenPro(TenantStore tenantStore)
{
foreach (var tenant in tenantStore.GetTenants().Values)
{
var connectionString = Configuration.GetConnectionString(tenant.DbContext.ConnectionKey);
RuntimeConfiguration.AddConnectionString(tenant.DbContext.ConnectionKey, connectionString);
// Enable low-level (result set) caching when specified in selected queries
// The cache of a query can be overwritten using property 'OverwriteIfPresent'
CacheController.RegisterCache(connectionString, new ResultsetCache());
CacheController.CachingEnabled = true;
}
if (WebHostEnvironment.IsProduction())
{
RuntimeConfiguration.ConfigureDQE <SD.LLBLGen.Pro.DQE.SqlServer.SQLServerDQEConfiguration>(c => c
.SetTraceLevel(TraceLevel.Off)
.AddDbProviderFactory(typeof(System.Data.SqlClient.SqlClientFactory)));
}
else
{
RuntimeConfiguration.ConfigureDQE <SD.LLBLGen.Pro.DQE.SqlServer.SQLServerDQEConfiguration>(c => c
.SetTraceLevel(TraceLevel.Verbose)
.AddDbProviderFactory(typeof(System.Data.SqlClient.SqlClientFactory)));
RuntimeConfiguration.Tracing.SetTraceLevel("ORMPersistenceExecution", TraceLevel.Verbose);
RuntimeConfiguration.Tracing.SetTraceLevel("ORMPlainSQLQueryExecution", TraceLevel.Verbose);
}
}
public async Task GetTenantCallsBlobStorageToRetrieveTenant()
{
var mockTenantBlobContainer = new Mock <IAzureBlobContainer <Tenant> >();
var store = new TenantStore(mockTenantBlobContainer.Object, null, new Mock <IInitializationStatusService>().Object);
await store.GetTenantAsync("tenant");
mockTenantBlobContainer.Verify(c => c.GetAsync("tenant"), Times.Once());
}
public void GetTenantCallsBlobStorageToRetrieveTenant()
{
var mockTenantBlobContainer = new Mock<IAzureBlobContainer<Tenant>>();
var store = new TenantStore(mockTenantBlobContainer.Object, null);
store.GetTenant("tenant");
mockTenantBlobContainer.Verify(c => c.Get("tenant"), Times.Once());
}
public void InitializeEnsuresContainerExists()
{
var mockTenantBlobContainer = new Mock<IAzureBlobContainer<Tenant>>();
var store = new TenantStore(mockTenantBlobContainer.Object, new Mock<IAzureBlobContainer<byte[]>>().Object);
store.Initialize();
mockTenantBlobContainer.Verify(c => c.EnsureExist(), Times.Once());
}
public void GetTenantCallsBlobStorageToRetrieveTenant()
{
var mockTenantBlobContainer = new Mock <IAzureBlobContainer <Tenant> >();
var store = new TenantStore(mockTenantBlobContainer.Object, null);
store.GetTenant("tenant");
mockTenantBlobContainer.Verify(c => c.Get("tenant"), Times.Once());
}
public async Task InitializeEnsuresContainerExists()
{
var mockTenantBlobContainer = new Mock <IAzureBlobContainer <Tenant> >();
var store = new TenantStore(mockTenantBlobContainer.Object, new Mock <IAzureBlobContainer <byte[]> >().Object, new Mock <IInitializationStatusService>().Object);
await store.InitializeAsync();
mockTenantBlobContainer.Verify(c => c.EnsureExistsAsync(), Times.Once());
}
public void InitializeEnsuresContainerExists()
{
var mockTenantBlobContainer = new Mock <IAzureBlobContainer <Tenant> >();
var store = new TenantStore(mockTenantBlobContainer.Object, new Mock <IAzureBlobContainer <byte[]> >().Object);
store.Initialize();
mockTenantBlobContainer.Verify(c => c.EnsureExist(), Times.Once());
}
private TenantStore GetTenantStore()
{
var store = cache.Get<TenantStore>(KEY);
if (store == null)
{
cache.Insert(KEY, store = new TenantStore(), DateTime.UtcNow.Add(CacheExpiration));
}
return store;
}
internal TenantStore GetTenantStore()
{
var store = Cache.Get <TenantStore>(KEY);
if (store == null)
{
Cache.Insert(KEY, store = new TenantStore(), DateTime.UtcNow.Add(CacheExpiration));
}
return(store);
}
public async Task <IViewComponentResult> InvokeAsync()
{
var model = new TenantSwitchViewModel();
if (CurrentTenant.Id.HasValue)
{
model.Tenant = await TenantStore.FindAsync(CurrentTenant.GetId());
}
return(View("~/Volo/Abp/AspNetCore/Mvc/UI/MultiTenancy/Components/TenantSwitch/Default.cshtml", model));
}
protected virtual async Task <TenantConfiguration> FindTenantAsync(string tenantIdOrName)
{
if (Guid.TryParse(tenantIdOrName, out var parsedTenantId))
{
return(await TenantStore.FindAsync(parsedTenantId));
}
else
{
return(await TenantStore.FindAsync(tenantIdOrName));
}
}
public async Task OnGetAsync()
{
Input = new TenantInfoModel();
if (CurrentTenant.IsAvailable)
{
var tenant = await TenantStore.FindAsync(CurrentTenant.GetId());
Input.Name = tenant?.Name;
}
}
public Home(ITenantContext tenantContext, TenantStore tenantStore, Axuno.BackgroundTask.IBackgroundQueue queue, SendEmailTask sendEmailTask, ILogger <Home> logger, IStringLocalizer <Account> localizer)
{
_tenantContext = tenantContext;
_tenantStore = tenantStore;
_appDb = _tenantContext.DbContext.AppDb;
_queue = queue;
_sendEmailTask = sendEmailTask;
_logger = logger;
_localizer = localizer;
_tenantContext = tenantContext;
}
public void GetTenantReturnsTenantFromBlobStorage()
{
var mockTenantBlobContainer = new Mock<IAzureBlobContainer<Tenant>>();
var store = new TenantStore(mockTenantBlobContainer.Object, null);
var tenant = new Tenant();
mockTenantBlobContainer.Setup(c => c.Get("tenant")).Returns(tenant);
var actualTenant = store.GetTenant("tenant");
Assert.AreSame(tenant, actualTenant);
}
private async Task <string> GetCurrentTenantNameAsync()
{
if (CurrentTenant.Id.HasValue && CurrentTenant.Name.IsNullOrEmpty())
{
var tenantConfiguration = await TenantStore.FindAsync(CurrentTenant.Id.Value);
return(tenantConfiguration.Name);
}
return(CurrentTenant.Name);
}
public void UploadLogoGetsTenatToUpdateFromContainer()
{
var mockLogosBlobContainer = new Mock<IAzureBlobContainer<byte[]>>();
var mockTenantContainer = new Mock<IAzureBlobContainer<Tenant>>();
var store = new TenantStore(mockTenantContainer.Object, mockLogosBlobContainer.Object);
mockTenantContainer.Setup(c => c.Get("tenant")).Returns(new Tenant() { Name = "tenant" }).Verifiable();
mockLogosBlobContainer.Setup(c => c.GetUri(It.IsAny<string>())).Returns(new Uri("http://bloburi"));
store.UploadLogo("tenant", new byte[1]);
mockTenantContainer.Verify();
}
public void GetTenantReturnsTenantFromBlobStorage()
{
var mockTenantBlobContainer = new Mock <IAzureBlobContainer <Tenant> >();
var store = new TenantStore(mockTenantBlobContainer.Object, null);
var tenant = new Tenant();
mockTenantBlobContainer.Setup(c => c.Get("tenant")).Returns(tenant);
var actualTenant = store.GetTenant("tenant");
Assert.AreSame(tenant, actualTenant);
}
public Cron(TenantStore tenantStore, ITenantContext tenantContext, IConfiguration configuration,
Axuno.BackgroundTask.IBackgroundQueue queue,
SendEmailTask sendMailTask, IMemoryCache cache, ILogger <Cron> logger)
{
_tenantContext = tenantContext;
_configuration = configuration;
_queue = queue;
_sendMailTask = sendMailTask;
_tenantStore = tenantStore;
_cache = cache;
_logger = logger;
}
public async Task GetTenantReturnsTenantFromBlobStorage()
{
var mockTenantBlobContainer = new Mock <IAzureBlobContainer <Tenant> >();
var store = new TenantStore(mockTenantBlobContainer.Object, null, new Mock <IInitializationStatusService>().Object);
var tenant = new Tenant();
mockTenantBlobContainer.Setup(c => c.GetAsync("tenant")).ReturnsAsync(tenant);
var actualTenant = await store.GetTenantAsync("tenant");
Assert.AreSame(tenant, actualTenant);
}
public void GetTenantNamesReturnsBlobNamesFromContainer()
{
var mockTenantBlobContainer = new Mock<IAzureBlobContainer<Tenant>>();
var store = new TenantStore(mockTenantBlobContainer.Object, null);
var blobs = new List<IListBlobItemWithName>() { new MockListBlobItem("b1"), new MockListBlobItem("b2") };
mockTenantBlobContainer.Setup(c => c.GetBlobList()).Returns(blobs);
var tenantNames = store.GetTenantNames().ToList();
Assert.AreEqual(2, tenantNames.Count());
CollectionAssert.Contains(tenantNames, "b1");
CollectionAssert.Contains(tenantNames, "b2");
}
public void UploadLogoGetsTenatToUpdateFromContainer()
{
var mockLogosBlobContainer = new Mock <IAzureBlobContainer <byte[]> >();
var mockTenantContainer = new Mock <IAzureBlobContainer <Tenant> >();
var store = new TenantStore(mockTenantContainer.Object, mockLogosBlobContainer.Object);
mockTenantContainer.Setup(c => c.Get("tenant")).Returns(new Tenant()
{
Name = "tenant"
}).Verifiable();
mockLogosBlobContainer.Setup(c => c.GetUri(It.IsAny <string>())).Returns(new Uri("http://bloburi"));
store.UploadLogo("tenant", new byte[1]);
mockTenantContainer.Verify();
}
public async Task UploadLogoSaveTenatWithLogoUrl()
{
var mockLogosBlobContainer = new Mock <IAzureBlobContainer <byte[]> >();
var mockTenantContainer = new Mock <IAzureBlobContainer <Tenant> >();
var store = new TenantStore(mockTenantContainer.Object, mockLogosBlobContainer.Object, new Mock <IInitializationStatusService>().Object);
mockTenantContainer.Setup(c => c.GetAsync("tenant")).ReturnsAsync(new Tenant()
{
TenantId = "tenant"
});
mockLogosBlobContainer.Setup(c => c.GetUri(It.IsAny <string>())).Returns(new Uri("http://bloburi/"));
await store.UploadLogoAsync("tenant", new byte[1]);
mockTenantContainer.Verify(c => c.SaveAsync("tenant", It.Is <Tenant>(t => t.Logo == "http://bloburi/")));
}
public void UploadLogoSaveTenatWithLogoUrl()
{
var mockLogosBlobContainer = new Mock <IAzureBlobContainer <byte[]> >();
var mockTenantContainer = new Mock <IAzureBlobContainer <Tenant> >();
var store = new TenantStore(mockTenantContainer.Object, mockLogosBlobContainer.Object);
mockTenantContainer.Setup(c => c.Get("tenant")).Returns(new Tenant()
{
Name = "tenant"
});
mockLogosBlobContainer.Setup(c => c.GetUri(It.IsAny <string>())).Returns(new Uri("http://bloburi/"));
store.UploadLogo("tenant", new byte[1]);
mockTenantContainer.Verify(c => c.Save("tenant", It.Is <Tenant>(t => t.Logo == "http://bloburi/")));
}
public async Task UploadLogoGetsTenatToUpdateFromContainer()
{
var mockLogosBlobContainer = new Mock <IAzureBlobContainer <byte[]> >();
var mockTenantContainer = new Mock <IAzureBlobContainer <Tenant> >();
var store = new TenantStore(mockTenantContainer.Object, mockLogosBlobContainer.Object, new Mock <IInitializationStatusService>().Object);
mockTenantContainer.Setup(c => c.GetAsync("tenant")).ReturnsAsync(new Tenant()
{
TenantId = "tenant"
}).Verifiable();
mockLogosBlobContainer.Setup(c => c.GetUri(It.IsAny <string>())).Returns(new Uri("http://bloburi"));
await store.UploadLogoAsync("tenant", new byte[1]);
mockTenantContainer.Verify();
}
public void UploadLogoSavesLogoToContainer()
{
var mockLogosBlobContainer = new Mock <IAzureBlobContainer <byte[]> >();
var mockTenantContainer = new Mock <IAzureBlobContainer <Tenant> >();
var store = new TenantStore(mockTenantContainer.Object, mockLogosBlobContainer.Object);
mockTenantContainer.Setup(c => c.Get("tenant")).Returns(new Tenant()
{
Name = "tenant"
});
mockLogosBlobContainer.Setup(c => c.GetUri(It.IsAny <string>())).Returns(new Uri("http://bloburi"));
var logo = new byte[1];
store.UploadLogo("tenant", logo);
mockLogosBlobContainer.Verify(c => c.Save("tenant", logo), Times.Once());
}
public void GetTenantNamesReturnsBlobNamesFromContainer()
{
var mockTenantBlobContainer = new Mock <IAzureBlobContainer <Tenant> >();
var store = new TenantStore(mockTenantBlobContainer.Object, null);
var blobs = new List <IListBlobItemWithName>()
{
new MockListBlobItem("b1"), new MockListBlobItem("b2")
};
mockTenantBlobContainer.Setup(c => c.GetBlobList()).Returns(blobs);
var tenantNames = store.GetTenantNames().ToList();
Assert.AreEqual(2, tenantNames.Count());
CollectionAssert.Contains(tenantNames, "b1");
CollectionAssert.Contains(tenantNames, "b2");
}
public async Task UploadLogoSavesLogoToContainer()
{
var mockLogosBlobContainer = new Mock <IAzureBlobContainer <byte[]> >();
var mockTenantContainer = new Mock <IAzureBlobContainer <Tenant> >();
var store = new TenantStore(mockTenantContainer.Object, mockLogosBlobContainer.Object, new Mock <IInitializationStatusService>().Object);
mockTenantContainer.Setup(c => c.GetAsync("tenant")).ReturnsAsync(new Tenant()
{
TenantId = "tenant"
});
mockLogosBlobContainer.Setup(c => c.GetUri(It.IsAny <string>())).Returns(new Uri("http://bloburi"));
var logo = new byte[1];
await store.UploadLogoAsync("tenant", logo);
mockLogosBlobContainer.Verify(c => c.SaveAsync("tenant", logo), Times.Once());
}
private TenantStore GetTenantStore(ref bool fromdb)
{
var store = cache.Get(KEY) as TenantStore;
if (store == null || interval.Expired || fromdb)
{
fromdb = true;
var date = store != null ? interval.StartTime : DateTime.MinValue;
interval.Start(DbExpiration);
var tenants = service.GetTenants(date);
if (store == null)
{
cache.Insert(KEY, store = new TenantStore(), CacheExpiration);
}
foreach (var t in tenants)
{
store.Insert(t);
}
}
return(store);
}
public virtual async Task OnPostAsync()
{
Guid?tenantId = null;
if (!Input.Name.IsNullOrEmpty())
{
var tenant = await TenantStore.FindAsync(Input.Name);
if (tenant == null)
{
throw new UserFriendlyException(L["GivenTenantIsNotExist", Input.Name]);
}
if (!tenant.IsActive)
{
throw new UserFriendlyException(L["GivenTenantIsNotAvailable", Input.Name]);
}
tenantId = tenant.Id;
}
AbpMultiTenancyCookieHelper.SetTenantCookie(HttpContext, tenantId, Options.TenantKey);
}
public LeaguesNavigationTreeBuilder(TenantStore tenantStore, IStringLocalizer <NavigationResource> localizer)
{
_tenantStore = tenantStore;
_localizer = localizer;
}
public void UploadLogoSavesLogoToContainer()
{
var mockLogosBlobContainer = new Mock<IAzureBlobContainer<byte[]>>();
var mockTenantContainer = new Mock<IAzureBlobContainer<Tenant>>();
var store = new TenantStore(mockTenantContainer.Object, mockLogosBlobContainer.Object);
mockTenantContainer.Setup(c => c.Get("tenant")).Returns(new Tenant() { Name = "tenant" });
mockLogosBlobContainer.Setup(c => c.GetUri(It.IsAny<string>())).Returns(new Uri("http://bloburi"));
var logo = new byte[1];
store.UploadLogo("tenant", logo);
mockLogosBlobContainer.Verify(c => c.Save("tenant", logo), Times.Once());
}
/// <summary>
/// Creates a tenant, user on the tenant and some todos with tags
/// </summary>
public static async Task SeedData(this IServiceProvider services, ILogger log)
{
/**
* Get registered services.
*/
var context = services.GetRequiredService <IDynamoDBContext>();
var idGenerator = services.GetRequiredService <IIdGenerator>();
var userRightsStore = services.GetRequiredService <IUserRightStore>();
var configuration = services.GetRequiredService <IConfiguration>();
/**
* Setup the provisioning user
*/
var provisioningUser = new User {
Id = TrustDefaults.ProvisioningId
};
/**
* Hand make up these because we want to inject the user with the provisioning user
*/
var tenantStore = new TenantStore(
provisioningUser,
context,
idGenerator,
userRightsStore,
services.GetRequiredService <ILogger <TenantStore> >());
var userStore = new UserStore(
provisioningUser,
context,
idGenerator,
userRightsStore,
services.GetRequiredService <ILogger <UserStore> >());
var tagStore = new TagStore(
provisioningUser,
context,
idGenerator,
userRightsStore,
services.GetRequiredService <ILogger <TagStore> >());
var todoStore = new TodoStore(
provisioningUser,
context,
idGenerator,
userRightsStore,
tagStore,
tenantStore,
services.GetRequiredService <ILogger <TodoStore> >());
// ensure the database is up and tables are created
await services.GetRequiredService <IAmazonDynamoDB>()
.WaitForAllTables(log);
log.Info("[Seed] create sample data");
//////////////////////////
// Authentication
// ==============
//
// A precreated user (in third-party system) [or decoded JWT through https://jwt.io
// grab it from the Authorization header in a request]
var knownAuth0Id = configuration.GetSection("TestSeedUser").Value;
log.DebugFormat("[Seed] found seed user '{0}'", knownAuth0Id);
var rootUser = (await userStore.GetByExternalId(TrustDefaults.KnownRootIdentifier))
.ThrowConfigurationErrorsExceptionIfNull(() => "Root user has not been configured");
//////////////////////////
// Seed a user
// =============
//
// Assume a known Auth0 (test) user, register a user and then link to tenant
//
var userData = new UserCreateData
{
Email = "*****@*****.**",
Name = "test",
ExternalId = knownAuth0Id
};
// create seeed data if the user doesn't exist
if ((await userStore.GetByExternalId(userData.ExternalId)).IsNull())
{
log.Info($"[Seed] user {userData.Email}");
var userId = await userStore.Create(
rootUser.Id,
TrustDefaults.KnownHomeResourceId,
userData,
Permission.FullControl | Permission.Owner,
CallerCollectionRights.User);
//////////////////////////
// Seed a tenant
// =============
//
var tenantCreateData = new TenantCreateData
{
Code = "rewire.semanticlink.io",
Name = "Rewire",
Description = "A sample tenant (company/organisation)"
};
log.Info($"[Seed] tenant '{tenantCreateData.Code}'");
var tenantId = await tenantStore.Create(
rootUser.Id,
TrustDefaults.KnownHomeResourceId,
tenantCreateData,
Permission.FullControl | Permission.Owner,
CallerCollectionRights.Tenant);
//////////////////////////
// Add user to tenant
// ==================
//
if (!await tenantStore.IsRegisteredOnTenant(tenantId, userId))
{
await tenantStore.IncludeUser(
tenantId,
userId,
Permission.Get | Permission.Owner,
CallerCollectionRights.Tenant);
}
log.Info($"[Seed] registered user '{userData.Email}' against tenant '{tenantCreateData.Code}'");
//////////////////////////
// Seed global tags
// =============
//
// create some global tags
//
var tagIds = (await Task.WhenAll(
new[] { "Work", "Personal", "Grocery List" }
.Select(tag => tagStore.Create(
userId,
TrustDefaults.KnownHomeResourceId,
new TagCreateData {
Name = tag
},
Permission.Get,
CallerCollectionRights.Tag)
)))
.Where(result => result != null)
.ToList();
log.InfoFormat("[Seed] tags: [{0}]", tagIds.ToCsvString(tagId => tagId));
/////////////////////////////////////
// Seed a named todo list
// ======================
//
var todoCreateData = new TodoCreateData
{
Parent = tenantId,
Name = "Shopping Todo List",
Type = TodoType.List
};
var todoListId = await todoStore.Create(
userId,
tenantId,
todoCreateData,
Permission.FullControl | Permission.Owner,
CallerCollectionRights.Todo);
log.InfoFormat("[Seed] todo list [{0}]", todoListId);
//////////////////////////
// Seed some todos
// ===============
//
var createTodoDatas = new List <TodoCreateData>
{
new TodoCreateData
{
Name = "One Todo",
Parent = todoListId,
Type = TodoType.Item
},
new TodoCreateData
{
Name = "Two Todo (tag)",
Tags = new List <string> {
tagIds.First()
},
State = TodoState.Complete,
Parent = todoListId,
Type = TodoType.Item
},
new TodoCreateData
{
Name = "Three Todo (tagged)",
Tags = tagIds,
Parent = todoListId,
Type = TodoType.Item
}
};
var ids = await Task.WhenAll(createTodoDatas
.Select(data => todoStore.Create(
userId,
userId,
data,
Permission.FullControl | Permission.Owner,
CallerCollectionRights.Todo)));
log.InfoFormat("[Seed] todos: [{0}]", ids.ToCsvString(id => id));
}
else
{
log.Debug("[Seed] test data already setup");
}
}
/// <summary>
/// CTOR.
/// </summary>
/// <param name="tenantStore"></param>
/// <param name="httpContextAccessor"></param>
public TenantResolver(TenantStore tenantStore, IHttpContextAccessor httpContextAccessor)
{
_tenantStore = tenantStore;
_httpContext = httpContextAccessor.HttpContext;
}
private TenantStore GetTenantStore()
{
var store = cache.Get(KEY) as TenantStore;
if (store == null)
{
cache.Insert(KEY, store = new TenantStore(), DateTime.UtcNow.Add(CacheExpiration));
}
return store;
}
public void UploadLogoSaveTenatWithLogoUrl()
{
var mockLogosBlobContainer = new Mock<IAzureBlobContainer<byte[]>>();
var mockTenantContainer = new Mock<IAzureBlobContainer<Tenant>>();
var store = new TenantStore(mockTenantContainer.Object, mockLogosBlobContainer.Object);
mockTenantContainer.Setup(c => c.Get("tenant")).Returns(new Tenant() { Name = "tenant" });
mockLogosBlobContainer.Setup(c => c.GetUri(It.IsAny<string>())).Returns(new Uri("http://bloburi/"));
store.UploadLogo("tenant", new byte[1]);
mockTenantContainer.Verify(c => c.Save("tenant", It.Is<Tenant>(t => t.Logo == "http://bloburi/")));
}
