public async Task Image_CreatedFromSyncSuccessfully()
{
// Arrange
var userId = 111;
var resp = new DigitalOcean.API.Models.Responses.Image()
{
Id = 888,
Slug = "s-1vcpu-1gbimage",
Name = "TestDroplet",
Tags = new List <string>()
{
"test", "Test2"
},
Type = "test image type",
Distribution = "test distribution",
Public = true,
Regions = new List <string>()
{
"nyc3"
},
CreatedAt = DateTime.Now,
MinDiskSize = 50,
SizeGigabytes = 53,
Description = "test image description",
Status = "running",
ErrorMessage = null
};
var apiResp = Task.FromResult(new List <DigitalOcean.API.Models.Responses.Image>()
{
resp
});
var apiClient = new Mock <IApiClient>();
apiClient.Setup(g => g.GetDropletsList()).Returns(Task.FromResult(new List <DigitalOcean.API.Models.Responses.Droplet>()));
apiClient.Setup(g => g.GetImagesList()).Returns(apiResp);
var manager = new DigitalOceanManager(DbContext, apiClient.Object);
// Act
await manager.FetchDropletsAsync(userId);
// Assert
var createdImage = await DbContext.Images.FirstOrDefaultAsync();
CheckBaseCreateInfo(userId, createdImage);
Assert.AreEqual(createdImage.DoUid, resp.Id);
Assert.AreEqual(createdImage.Name, resp.Name);
Assert.AreEqual(createdImage.Type, resp.Type);
Assert.AreEqual(createdImage.Distribution, resp.Distribution);
Assert.AreEqual(createdImage.Slug, resp.Slug);
Assert.AreEqual(createdImage.Public, resp.Public);
Assert.AreEqual(createdImage.ImageCreatedAt, resp.CreatedAt);
Assert.AreEqual(createdImage.MinDiskSize, resp.MinDiskSize);
Assert.AreEqual(createdImage.SizeGigabytes, resp.SizeGigabytes);
Assert.AreEqual(createdImage.Description, resp.Description);
Assert.AreEqual(createdImage.Status, resp.Status);
Assert.IsNull(createdImage.ErrorMessage);
}
public async Task Image_RemovedAfterSyncSuccessfully()
{
// Arrange
var userId = 111;
var apiResp = Task.FromResult(new List <DigitalOcean.API.Models.Responses.Image>()
{
});
var apiClient = new Mock <IApiClient>();
apiClient.Setup(g => g.GetDropletsList()).Returns(Task.FromResult(new List <DigitalOcean.API.Models.Responses.Droplet>()));
apiClient.Setup(g => g.GetImagesList()).Returns(apiResp);
var manager = new DigitalOceanManager(DbContext, apiClient.Object);
var firstImage = new Image()
{
DoUid = 9999,
Slug = "s-1vcpu-1gbimage",
Name = "TestDroplet",
Type = "test image type",
Distribution = "test distribution",
Public = true,
CreatedAt = DateTime.Now,
MinDiskSize = 50,
SizeGigabytes = 53,
Description = "test image description",
Status = "running",
CreatedByUserId = userId,
Version = 1,
WorkflowState = WorkflowStates.Created,
ImageCreatedAt = DateTime.Now,
ErrorMessage = null
};
await DbContext.Images.AddAsync(firstImage);
await DbContext.SaveChangesAsync();
// Act
await manager.FetchDropletsAsync(userId);
// Assert
var updatedImageList = await DbContext.Images.ToListAsync();
var updatedImage = updatedImageList.Last();
CheckBaseRemoveInfo(userId, updatedImage);
Assert.AreEqual(updatedImage.DoUid, firstImage.DoUid);
Assert.AreEqual(updatedImage.Name, firstImage.Name);
Assert.AreEqual(updatedImage.Type, firstImage.Type);
Assert.AreEqual(updatedImage.Distribution, firstImage.Distribution);
Assert.AreEqual(updatedImage.Slug, firstImage.Slug);
Assert.AreEqual(updatedImage.Public, firstImage.Public);
Assert.AreEqual(updatedImage.ImageCreatedAt, firstImage.ImageCreatedAt);
Assert.AreEqual(updatedImage.MinDiskSize, firstImage.MinDiskSize);
Assert.AreEqual(updatedImage.SizeGigabytes, firstImage.SizeGigabytes);
Assert.AreEqual(updatedImage.Description, firstImage.Description);
Assert.AreEqual(updatedImage.Status, firstImage.Status);
Assert.IsNull(updatedImage.ErrorMessage);
}
public async Task DropletRebuildSuccessfull()
{
// Arrange
var userId = 111;
var dropletResp = new DigitalOcean.API.Models.Responses.Droplet()
{
Id = 777,
Size = new DigitalOcean.API.Models.Responses.Size()
{
Regions = new List <string>()
{
"nyc3"
},
Memory = 1,
PriceHourly = 5,
PriceMonthly = 30,
Slug = "khkhjkh",
Transfer = 2.6,
Vcpus = 6,
Disk = 22
},
SizeSlug = "s-1vcpu-1gb",
Name = "TestDroplet",
Networks = new DigitalOcean.API.Models.Responses.Network
{
V4 = new List <DigitalOcean.API.Models.Responses.InterfaceV4>
{
new DigitalOcean.API.Models.Responses.InterfaceV4()
{
IpAddress = "testv4",
Type = "public",
},
new DigitalOcean.API.Models.Responses.InterfaceV4()
{
IpAddress = "testv4private",
Type = "private",
}
},
V6 = new List <DigitalOcean.API.Models.Responses.InterfaceV6>()
{
new DigitalOcean.API.Models.Responses.InterfaceV6()
{
IpAddress = "testv6",
Type = "public"
}
}
},
Tags = new List <string>()
{
"test", "Test2"
},
Image = new DigitalOcean.API.Models.Responses.Image
{
Id = 888,
Name = "MyTestImage"
},
Features = new List <string>()
{
"ipv6", "backups", "monitoring"
},
};
var imageResp = new DigitalOcean.API.Models.Responses.Image()
{
Id = 888,
Slug = "s-1vcpu-1gbimage",
Name = "TestDroplet",
Tags = new List <string>()
{
"test", "Test2"
},
Type = "test image type",
Distribution = "test distribution",
Public = true,
Regions = new List <string>()
{
"nyc3"
},
CreatedAt = DateTime.Now,
MinDiskSize = 50,
SizeGigabytes = 53,
Description = "test image description",
Status = "running",
ErrorMessage = null
};
var rebuildResp = new DigitalOcean.API.Models.Responses.Action()
{
Status = "completed"
};
var apiDropletResp = Task.FromResult(new List <DigitalOcean.API.Models.Responses.Droplet>()
{
dropletResp
});
var apiImageResp = Task.FromResult(new List <DigitalOcean.API.Models.Responses.Image>()
{
imageResp
});
var apiClient = new Mock <IApiClient>();
apiClient.Setup(g => g.GetDroplet(It.IsAny <int>())).Returns(Task.FromResult(dropletResp));
apiClient.Setup(g => g.GetDropletsList()).Returns(apiDropletResp);
apiClient.Setup(g => g.RebuildDroplet(It.IsAny <long>(), It.IsAny <long>())).Returns(Task.FromResult(rebuildResp));
apiClient.Setup(g => g.GetImagesList()).Returns(apiImageResp);
var manager = new DigitalOceanManager(DbContext, apiClient.Object);
// Act
await manager.FetchDropletsAsync(userId);
await manager.RebuildDropletAsync(userId, 777, 888);
// Assert
var createdDroplet = await DbContext.Droplets.Where(t => t.Id == 1).FirstOrDefaultAsync();
var createdSize = await DbContext.Sizes.Where(t => t.Id == 1).FirstOrDefaultAsync();
var createdTags = await DbContext.Tags.ToListAsync();
var createdDropletTags = await DbContext.DropletTag.Where(t => t.DropletId == createdDroplet.Id).ToListAsync();
var createdRegions = await DbContext.Regions.ToListAsync();
var createdSizeRegions = await DbContext.SizeRegion.Where(t => t.SizeId == createdSize.Id).ToListAsync();
// tags
Assert.IsTrue(createdTags.Select(t => t.Name).Except(dropletResp.Tags).Count() == 0);
foreach (var tag in createdTags)
{
CheckBaseCreateInfo(userId, tag);
Assert.IsNotNull(tag.Name);
}
// regions
Assert.IsTrue(createdRegions.Select(t => t.Name).Except(dropletResp.Size.Regions).Count() == 0);
foreach (var reg in createdRegions)
{
CheckBaseCreateInfo(userId, reg);
Assert.IsNotNull(reg.Name);
}
// size
CheckBaseUpdateInfo(userId, createdSize, 2);
Assert.AreEqual(createdSize.Memory, dropletResp.Size.Memory);
Assert.AreEqual(createdSize.PriceHourly, dropletResp.Size.PriceHourly);
Assert.AreEqual(createdSize.PriceMonthly, dropletResp.Size.PriceMonthly);
Assert.AreEqual(createdSize.Slug, dropletResp.Size.Slug);
Assert.AreEqual(createdSize.Transfer, dropletResp.Size.Transfer);
Assert.AreEqual(createdSize.Vcpus, dropletResp.Size.Vcpus);
Assert.AreEqual(createdSize.Disk, dropletResp.Size.Disk);
// droplet
CheckBaseUpdateInfo(userId, createdDroplet, 3);
Assert.AreEqual(createdDroplet.DoUid, dropletResp.Id);
Assert.AreEqual(createdDroplet.CustomerNo, 0);
Assert.AreEqual(createdDroplet.PublicIpV4, dropletResp.Networks.V4[0].IpAddress);
Assert.AreEqual(createdDroplet.PrivateIpV4, dropletResp.Networks.V4[1].IpAddress);
Assert.AreEqual(createdDroplet.PublicIpV6, dropletResp.Networks.V6[0].IpAddress);
Assert.AreEqual(createdDroplet.CurrentImageName, dropletResp.Image.Name);
Assert.AreEqual(null, createdDroplet.RequestedImageName);
Assert.AreEqual(createdDroplet.CurrentImageId, dropletResp.Image.Id);
Assert.AreEqual(0, createdDroplet.RequestedImageId);
Assert.IsNull(createdDroplet.UserData);
Assert.AreEqual(createdDroplet.MonitoringEnabled, dropletResp.Features.Contains("monitoring"));
Assert.AreEqual(createdDroplet.IpV6Enabled, dropletResp.Features.Contains("ipv6"));
Assert.AreEqual(createdDroplet.BackupsEnabled, dropletResp.Features.Contains("backups"));
Assert.AreEqual(createdDroplet.Sizeid, createdSize.Id);
// TODO Add tests for DropletVersions
// dropletTag
Assert.AreEqual(createdDropletTags.Count, createdTags.Count);
foreach (var dt in createdDropletTags)
{
CheckBaseUpdateInfo(userId, dt);
Assert.AreEqual(createdDroplet.Id, dt.DropletId);
Assert.IsTrue(createdTags.Select(t => t.Id).Contains(dt.TagId));
}
// regionsize
Assert.AreEqual(createdSizeRegions.Count, createdRegions.Count);
foreach (var sr in createdSizeRegions)
{
CheckBaseUpdateInfo(userId, sr);
Assert.AreEqual(createdSize.Id, sr.SizeId);
Assert.IsTrue(createdRegions.Select(t => t.Id).Contains(sr.RegionId));
}
}
public async Task Droplet_CretedSuccessfully()
{
// Arrange
var userId = 111;
var apiResp = Task.FromResult(new DigitalOcean.API.Models.Responses.Droplet()
{
Id = 777,
Size = new DigitalOcean.API.Models.Responses.Size()
{
Regions = new List <string>()
{
"nyc3"
},
Memory = 1,
PriceHourly = 5,
PriceMonthly = 30,
Slug = "khkhjkh",
Transfer = 2.6,
Vcpus = 6,
Disk = 22
},
SizeSlug = "s-1vcpu-1gb",
Name = "TestDroplet",
Networks = new DigitalOcean.API.Models.Responses.Network
{
V4 = new List <DigitalOcean.API.Models.Responses.InterfaceV4>
{
new DigitalOcean.API.Models.Responses.InterfaceV4()
{
IpAddress = "testv4",
Type = "public",
},
new DigitalOcean.API.Models.Responses.InterfaceV4()
{
IpAddress = "testv4private",
Type = "private",
}
},
V6 = new List <DigitalOcean.API.Models.Responses.InterfaceV6>()
{
new DigitalOcean.API.Models.Responses.InterfaceV6()
{
IpAddress = "testv6",
Type = "public"
}
}
},
Tags = new List <string>()
{
"test", "Test2"
},
Image = new DigitalOcean.API.Models.Responses.Image
{
Id = 888,
Name = "MyTestImage"
},
Features = new List <string>()
{
"ipv6", "backups", "monitoring"
},
});
var apiClient = new Mock <IApiClient>();
apiClient.Setup(g => g.CreateDroplet(It.IsAny <CreateDropletRequest>())).Returns(apiResp);
var manager = new DigitalOceanManager(DbContext, apiClient.Object, Mapper);
// Act
var droplet = await manager.CreateDropletAsync(userId, new CreateDropletRequest()
{
Name = "TestDroplet",
Region = "nyc3",
Size = "s-1vcpu-1gb",
Image = "ubuntu-16-04-x64",
Tags = new List <string>()
{
"test", "Test2"
},
Ipv6 = true,
PrivateNetworking = true,
Monitoring = true,
});
// Assert
var createdDroplet = await DbContext.Droplets.FirstOrDefaultAsync();
var createdSize = await DbContext.Sizes.FirstOrDefaultAsync();
var createdTags = await DbContext.Tags.ToListAsync();
var createdDropletTags = await DbContext.DropletTag.ToListAsync();
var createdRegions = await DbContext.Regions.ToListAsync();
var createdSizeRegions = await DbContext.SizeRegion.ToListAsync();
// tags
Assert.IsTrue(createdTags.Select(t => t.Name).Except(apiResp.Result.Tags).Count() == 0);
foreach (var tag in createdTags)
{
CheckBaseCreateInfo(userId, tag);
Assert.IsNotNull(tag.Name);
}
// regions
Assert.IsTrue(createdRegions.Select(t => t.Name).Except(apiResp.Result.Size.Regions).Count() == 0);
foreach (var reg in createdRegions)
{
CheckBaseCreateInfo(userId, reg);
Assert.IsNotNull(reg.Name);
}
// size
CheckBaseCreateInfo(userId, createdSize);
Assert.AreEqual(createdSize.Memory, apiResp.Result.Size.Memory);
Assert.AreEqual(createdSize.PriceHourly, apiResp.Result.Size.PriceHourly);
Assert.AreEqual(createdSize.PriceMonthly, apiResp.Result.Size.PriceMonthly);
Assert.AreEqual(createdSize.Slug, apiResp.Result.Size.Slug);
Assert.AreEqual(createdSize.Transfer, apiResp.Result.Size.Transfer);
Assert.AreEqual(createdSize.Vcpus, apiResp.Result.Size.Vcpus);
Assert.AreEqual(createdSize.Disk, apiResp.Result.Size.Disk);
// droplet
CheckBaseCreateInfo(userId, createdDroplet);
Assert.AreEqual(createdDroplet.DoUid, apiResp.Result.Id);
Assert.AreEqual(createdDroplet.CustomerNo, 0);
Assert.AreEqual(createdDroplet.PublicIpV4, apiResp.Result.Networks.V4[0].IpAddress);
Assert.AreEqual(createdDroplet.PrivateIpV4, apiResp.Result.Networks.V4[1].IpAddress);
Assert.AreEqual(createdDroplet.PublicIpV6, apiResp.Result.Networks.V6[0].IpAddress);
Assert.AreEqual(createdDroplet.CurrentImageName, apiResp.Result.Image.Name);
Assert.IsNull(createdDroplet.RequestedImageName);
Assert.AreEqual(createdDroplet.CurrentImageId, apiResp.Result.Image.Id);
Assert.AreEqual(createdDroplet.RequestedImageId, 0);
Assert.IsNull(createdDroplet.UserData);
Assert.AreEqual(createdDroplet.MonitoringEnabled, apiResp.Result.Features.Contains("monitoring"));
Assert.AreEqual(createdDroplet.IpV6Enabled, apiResp.Result.Features.Contains("ipv6"));
Assert.AreEqual(createdDroplet.BackupsEnabled, apiResp.Result.Features.Contains("backups"));
Assert.AreEqual(createdDroplet.Sizeid, createdSize.Id);
// dropletTag
Assert.AreEqual(createdDropletTags.Count, createdTags.Count);
foreach (var dt in createdDropletTags)
{
CheckBaseCreateInfo(userId, dt);
Assert.AreEqual(createdDroplet.Id, dt.DropletId);
Assert.IsTrue(createdTags.Select(t => t.Id).Contains(dt.Id));
}
// regionsize
Assert.AreEqual(createdSizeRegions.Count, createdRegions.Count);
foreach (var sr in createdSizeRegions)
{
CheckBaseCreateInfo(userId, sr);
Assert.AreEqual(createdSize.Id, sr.SizeId);
Assert.IsTrue(createdRegions.Select(t => t.Id).Contains(sr.Id));
}
}
public async Task Droplet_RemovedFromSyncSuccessfully()
{
// Arrange
var userId = 111;
#region synced first droplet
var firstDropletResponse = new DigitalOcean.API.Models.Responses.Droplet()
{
Id = 777,
Size = new DigitalOcean.API.Models.Responses.Size()
{
Regions = new List <string>()
{
"nyc3"
},
Memory = 1,
PriceHourly = 5,
PriceMonthly = 30,
Slug = "khkhjkh",
Transfer = 2.6,
Vcpus = 6,
Disk = 22
},
SizeSlug = "s-1vcpu-1gb",
Name = "TestDroplet",
Networks = new DigitalOcean.API.Models.Responses.Network
{
V4 = new List <DigitalOcean.API.Models.Responses.InterfaceV4>
{
new DigitalOcean.API.Models.Responses.InterfaceV4()
{
IpAddress = "testv4",
Type = "public",
},
new DigitalOcean.API.Models.Responses.InterfaceV4()
{
IpAddress = "testv4private",
Type = "private",
}
},
V6 = new List <DigitalOcean.API.Models.Responses.InterfaceV6>()
{
new DigitalOcean.API.Models.Responses.InterfaceV6()
{
IpAddress = "testv6",
Type = "public"
}
}
},
Tags = new List <string>()
{
"test", "Test2"
},
Image = new DigitalOcean.API.Models.Responses.Image
{
Id = 888,
Name = "MyTestImage"
},
Features = new List <string>()
{
"ipv6", "backups", "monitoring"
},
};
var apiResp = Task.FromResult(new List <DigitalOcean.API.Models.Responses.Droplet>()
{
firstDropletResponse
});
var apiClient = new Mock <IApiClient>();
apiClient.Setup(g => g.GetDropletsList()).Returns(apiResp);
var manager = new DigitalOceanManager(DbContext, apiClient.Object);
await manager.FetchDropletsAsync(userId);
#endregion
var apiResp2 = Task.FromResult(new List <DigitalOcean.API.Models.Responses.Droplet>()
{
});
apiClient.Setup(g => g.GetDropletsList()).Returns(apiResp2);
// Act
await manager.FetchDropletsAsync(userId);
// Assert
var createdDroplet = (await DbContext.Droplets.AsNoTracking().ToListAsync()).Last();
var createdSize = (await DbContext.Sizes.AsNoTracking().ToListAsync()).Last();
var createdDropletTags = await DbContext.DropletTag.AsNoTracking().Where(t => t.DropletId == createdDroplet.Id).ToListAsync();
var createdSizeRegions = await DbContext.SizeRegion.AsNoTracking().Where(t => t.SizeId == createdSize.Id).ToListAsync();
var createdTags = (await DbContext.Tags.AsNoTracking().ToListAsync())
.Where(t => createdDropletTags.Select(t => t.TagId)
.Contains(t.Id))
.ToList();
var createdRegions = (await DbContext.Regions.AsNoTracking().ToListAsync())
.Where(t => createdSizeRegions.Select(t => t.RegionId)
.Contains(t.Id))
.ToList();
// tags
Assert.IsTrue(createdTags.Select(t => t.Name).Except(firstDropletResponse.Tags).Count() == 0);
foreach (var tag in createdTags)
{
CheckBaseCreateInfo(userId, tag);
Assert.IsNotNull(tag.Name);
}
// regions
Assert.IsTrue(createdRegions.Select(t => t.Name).Except(firstDropletResponse.Size.Regions).Count() == 0);
foreach (var reg in createdRegions)
{
CheckBaseCreateInfo(userId, reg);
Assert.IsNotNull(reg.Name);
}
// size
CheckBaseRemoveInfo(userId, createdSize);
Assert.AreEqual(createdSize.Memory, firstDropletResponse.Size.Memory);
Assert.AreEqual(createdSize.PriceHourly, firstDropletResponse.Size.PriceHourly);
Assert.AreEqual(createdSize.PriceMonthly, firstDropletResponse.Size.PriceMonthly);
Assert.AreEqual(createdSize.Slug, firstDropletResponse.Size.Slug);
Assert.AreEqual(createdSize.Transfer, firstDropletResponse.Size.Transfer);
Assert.AreEqual(createdSize.Vcpus, firstDropletResponse.Size.Vcpus);
Assert.AreEqual(createdSize.Disk, firstDropletResponse.Size.Disk);
// droplet
CheckBaseRemoveInfo(userId, createdDroplet);
Assert.AreEqual(createdDroplet.DoUid, firstDropletResponse.Id);
Assert.AreEqual(createdDroplet.CustomerNo, 0);
Assert.AreEqual(createdDroplet.PublicIpV4, firstDropletResponse.Networks.V4[0].IpAddress);
Assert.AreEqual(createdDroplet.PrivateIpV4, firstDropletResponse.Networks.V4[1].IpAddress);
Assert.AreEqual(createdDroplet.PublicIpV6, firstDropletResponse.Networks.V6[0].IpAddress);
Assert.AreEqual(createdDroplet.CurrentImageName, firstDropletResponse.Image.Name);
Assert.IsNull(createdDroplet.RequestedImageName);
Assert.AreEqual(createdDroplet.CurrentImageId, firstDropletResponse.Image.Id);
Assert.AreEqual(createdDroplet.RequestedImageId, 0);
Assert.IsNull(createdDroplet.UserData);
Assert.AreEqual(createdDroplet.MonitoringEnabled, firstDropletResponse.Features.Contains("monitoring"));
Assert.AreEqual(createdDroplet.IpV6Enabled, firstDropletResponse.Features.Contains("ipv6"));
Assert.AreEqual(createdDroplet.BackupsEnabled, firstDropletResponse.Features.Contains("backups"));
Assert.AreEqual(createdDroplet.Sizeid, createdSize.Id);
// dropletTag
Assert.AreEqual(createdDropletTags.Count, createdTags.Count);
foreach (var dt in createdDropletTags)
{
CheckBaseRemoveInfo(userId, dt);
Assert.AreEqual(createdDroplet.Id, dt.DropletId);
Assert.IsTrue(createdTags.Select(t => t.Id).Contains(dt.TagId));
}
// regionsize
Assert.AreEqual(createdSizeRegions.Count, createdRegions.Count);
foreach (var sr in createdSizeRegions)
{
CheckBaseCreateInfo(userId, sr);
Assert.AreEqual(createdSize.Id, sr.SizeId);
Assert.IsTrue(createdRegions.Select(t => t.Id).Contains(sr.RegionId));
}
}
