[Fact] public void Case1()
{
var sut = new Sut();
var errI = sut as IDataErrorInfo;
Assert.Equal("", errI["OptionalText"]);
Assert.Equal("“RequiredText” should not be ‹NULL›.", errI["RequiredText"]);
Assert.Equal("“RequiredText” should not be ‹NULL›.", errI.Error);
sut.OptionalText = "abc";
sut.RequiredText = "abc";
Assert.Equal("", errI["OptionalText"]);
Assert.Equal("", errI["RequiredText"]);
Assert.Equal("", errI.Error);
sut.OptionalText = "";
sut.RequiredText = "";
Assert.Equal("", errI["OptionalText"]);
Assert.Equal("“RequiredText” should not be ‹BLANK›.", errI["RequiredText"]);
Assert.Equal("“RequiredText” should not be ‹BLANK›.", errI.Error);
sut.RequiredText = " ";
Assert.Equal("“RequiredText” should not be ‹BLANK›.", errI["RequiredText"]);
}
public void FilterIn()
{
var sut = new Sut();
Assert.IsTrue(sut.FilterIn("foo"));
Assert.IsFalse(sut.FilterIn("z"));
Assert.IsTrue(sut.FilterIn("TWO"));
}
public void HasText2()
{
var sut = new Sut();
Assert.IsTrue(sut.HasText2);
sut.text2 = null;
Assert.IsFalse(sut.HasText2);
sut.text2 = string.Empty;
Assert.IsFalse(sut.HasText2);
}
public void TestInitialize()
{
sut = new Sut();
var sugar = new Sugar();
var factories = Substitute.For<Factories>();
sugarViewModel = new SugarViewModel(sugar, factories);
var stateProvider = Substitute.For<StateProvider>();
stateProvider.State.Returns(new Dictionary<string, object>());
factories.Settings.Returns(new Settings());
sut.StateProvider = stateProvider;
}
public void NonExistent()
{
var sut = new Sut { FsShim = _fs };
var errI = sut as IDataErrorInfo;
var none = @"C:\abc\non-existent.file";
sut.Optional = none;
sut.Required = none;
Assert.Equal($"“Optional” does not exist as a file in {none}.", errI["Optional"]);
Assert.Equal($"“Required” does not exist as a file in {none}.", errI["Required"]);
}
public void HappyPath()
{
var sut = new Sut { FsShim = _fs };
var errI = sut as IDataErrorInfo;
var file = _fs.TempFile("");
sut.Optional = file.Path;
sut.Required = file.Path;
Assert.Equal("", errI["Optional"]);
Assert.Equal("", errI["Required"]);
}
public void Case1()
{
var sut = new Sut { FsShim = _fs };
var errI = sut as IDataErrorInfo;
var file = _fs.TempFile("");
sut.Optional = file.Path;
sut.Required = file.Path;
Assert.Equal($"“Optional” does not exist as a folder in {file.Path}.", errI["Optional"]);
Assert.Equal($"“Required” does not exist as a folder in {file.Path}.", errI["Required"]);
}
public void HappyPath()
{
var sut = new Sut { FsShim = _fs };
var errI = sut as IDataErrorInfo;
var folder = _fs.GetSpecialDir(SpecialDir.Desktop);
sut.Optional = folder;
sut.Required = folder;
Assert.Equal("", errI["Optional"]);
Assert.Equal("", errI["Required"]);
}
public void Case1()
{
var sut = new Sut { FsShim = _fs };
var errI = sut as IDataErrorInfo;
var folder = _fs.GetSpecialDir(SpecialDir.Desktop);
sut.Optional = folder;
sut.Required = folder;
Assert.Equal($"“Optional” does not exist as a file in {folder}.", errI["Optional"]);
Assert.Equal($"“Required” does not exist as a file in {folder}.", errI["Required"]);
}
public void NullOrBlank()
{
var sut = new Sut { FsShim = _fs };
var errI = sut as IDataErrorInfo;
Assert.Equal("", errI["Optional"]);
Assert.Equal("“Required” should not be ‹NULL›.", errI["Required"]);
sut.Optional = "";
sut.Required = "";
Assert.Equal("", errI["Optional"]);
Assert.Equal("“Required” should not be ‹BLANK›.", errI["Required"]);
}
[Fact] public void Test_Min0()
{
var sut = new Sut();
var errI = sut as IDataErrorInfo;
sut.Min0 = 0;
Assert.Equal("", errI["Min0"]);
Assert.Equal("", errI.Error);
sut.Min0 = 3;
Assert.Equal("", errI["Min0"]);
Assert.Equal("", errI.Error);
sut.Min0 = -1;
Assert.Equal("“Min0” should not be less than 0.", errI["Min0"]);
Assert.Equal("“Min0” should not be less than 0.", errI.Error);
sut.Min1 = 0;
Assert.Equal("“Min0” should not be less than 0.", errI["Min0"]);
Assert.Equal("“Min1” should not be less than 1.", errI["Min1"]);
Assert.Equal("“Min0” should not be less than 0."
+ L.f + "“Min1” should not be less than 1.", errI.Error);
}
public void when_order_paired_then_order_dto_populated()
{
var @event = new OrderManuallyPairedForRideLinq
{
SourceId = Guid.NewGuid(),
AccountId = Guid.NewGuid(),
TripId = 15,
PairingDate = DateTime.Now,
PickupAddress = new Address
{
Apartment = "3939",
Street = "1234 rue Saint-Hubert",
RingCode = "3131",
Latitude = 45.515065,
Longitude = -73.558064
},
UserAgent = "useragent",
ClientLanguageCode = "en",
ClientVersion = "1.0",
OriginatingIpAddress = "192.168.12.30",
KountSessionId = "1i3u13n123",
Medallion = "1251515",
DriverId = 124135356,
PairingCode = "515152",
PairingToken = "62523",
CreditCardId = Guid.NewGuid()
};
Sut.Handle(@event);
using (var context = new BookingDbContext(DbName))
{
var order = context.Query <OrderDetail>().SingleOrDefault(x => x.Id == @event.SourceId);
Assert.IsNotNull(order);
Assert.AreEqual(@event.AccountId, order.AccountId);
Assert.AreEqual(@event.TripId, order.IBSOrderId);
Assert.AreEqual(@event.PairingDate.ToLongDateString(), order.CreatedDate.ToLongDateString());
Assert.AreEqual(@event.PickupAddress.DisplayLine1, order.PickupAddress.DisplayLine1);
Assert.AreEqual((int)OrderStatus.Created, order.Status);
Assert.AreEqual(@event.UserAgent, order.UserAgent);
Assert.AreEqual(@event.ClientLanguageCode, order.ClientLanguageCode);
Assert.AreEqual(@event.ClientVersion, order.ClientVersion);
Assert.AreEqual(true, order.IsManualRideLinq);
Assert.AreEqual(@event.OriginatingIpAddress, order.OriginatingIpAddress);
Assert.AreEqual(@event.KountSessionId, order.KountSessionId);
Assert.IsTrue(order.PaymentInformation.PayWithCreditCard);
Assert.AreEqual(ChargeTypes.CardOnFile.Id, order.Settings.ChargeTypeId);
Assert.AreEqual(@event.CreditCardId, order.PaymentInformation.CreditCardId);
var orderStatus = context.Query <OrderStatusDetail>().SingleOrDefault(x => x.OrderId == @event.SourceId);
Assert.IsNotNull(orderStatus);
Assert.AreEqual(@event.AccountId, orderStatus.AccountId);
Assert.AreEqual(OrderStatus.Created, orderStatus.Status);
Assert.AreEqual("Processing your order...", orderStatus.IBSStatusDescription);
Assert.AreEqual(@event.Medallion, orderStatus.VehicleNumber);
Assert.AreEqual(@event.DriverId.ToString(), orderStatus.DriverInfos.DriverId);
var orderRideLinq = context.Query <OrderManualRideLinqDetail>().SingleOrDefault(x => x.OrderId == @event.SourceId);
Assert.IsNotNull(orderRideLinq);
Assert.AreEqual(@event.AccountId, orderRideLinq.AccountId);
Assert.AreEqual(@event.PairingCode, orderRideLinq.PairingCode);
Assert.AreEqual(@event.PairingToken, orderRideLinq.PairingToken);
Assert.AreEqual(@event.PairingDate.ToLongDateString(), orderRideLinq.PairingDate.ToLongDateString());
Assert.AreEqual(@event.Distance, orderRideLinq.Distance);
Assert.AreEqual(@event.Extra, orderRideLinq.Extra);
Assert.AreEqual(@event.Fare, orderRideLinq.Fare);
Assert.AreEqual(@event.FareAtAlternateRate, orderRideLinq.FareAtAlternateRate);
Assert.AreEqual(@event.Total, orderRideLinq.Total);
Assert.AreEqual(@event.Toll, orderRideLinq.Toll);
Assert.AreEqual(@event.Tax, orderRideLinq.Tax);
Assert.AreEqual(@event.Tip, orderRideLinq.Tip);
Assert.AreEqual(@event.Surcharge, orderRideLinq.Surcharge);
Assert.AreEqual(@event.RateAtTripStart, orderRideLinq.RateAtTripStart);
Assert.AreEqual(@event.RateAtTripEnd, orderRideLinq.RateAtTripEnd);
Assert.AreEqual(@event.RateChangeTime, orderRideLinq.RateChangeTime);
Assert.AreEqual(@event.Medallion, orderRideLinq.Medallion);
Assert.AreEqual(@event.DeviceName, orderRideLinq.DeviceName);
Assert.AreEqual(@event.TripId, orderRideLinq.TripId);
Assert.AreEqual(@event.DriverId, orderRideLinq.DriverId);
Assert.AreEqual(@event.LastFour, orderRideLinq.LastFour);
Assert.AreEqual(@event.AccessFee, orderRideLinq.AccessFee);
}
}
public void ShouldCreateNewEntity()
{
var entity = Sut.Create("test", "test");
entity.Version.Should().Be(Internal.EntityFactory.NewEntityVersion);
}
protected override void Act()
{
Returned = Sut.Create();
}
public void when_order_created_then_order_dto_populated()
{
var orderId = Guid.NewGuid();
var accountId = Guid.NewGuid();
var pickupDate = DateTime.Now.AddDays(1);
var createdDate = DateTime.Now;
Sut.Handle(new OrderCreated
{
SourceId = orderId,
AccountId = accountId,
PickupAddress = new Address
{
Apartment = "3939",
Street = "1234 rue Saint-Hubert",
RingCode = "3131",
Latitude = 45.515065,
Longitude = -73.558064
},
PickupDate = pickupDate,
DropOffAddress = new Address
{
FriendlyName = "Velvet auberge st gabriel",
Latitude = 45.50643,
Longitude = -73.554052,
},
Settings = new BookingSettings
{
ChargeTypeId = 99,
VehicleTypeId = 98,
ProviderId = 97,
NumberOfTaxi = 96,
Passengers = 95,
Phone = "94",
Name = "93",
LargeBags = 92,
AccountNumber = "account",
CustomerNumber = "customer",
PayBack = "123"
},
CreatedDate = createdDate,
ClientLanguageCode = "fr",
UserAgent = "TestUserAgent",
ClientVersion = "1.0.0",
UserNote = "une note",
BookingFees = 5m,
Market = "MTL",
CompanyKey = "Kramerica",
CompanyName = "Kramerica Industries",
EstimatedFare = 50.5,
IsChargeAccountPaymentWithCardOnFile = true,
IsPrepaid = true,
OriginatingIpAddress = "192.168.12.30",
KountSessionId = "1i3u13n123"
});
using (var context = new BookingDbContext(DbName))
{
var list = context.Query <OrderDetail>().Where(x => x.Id == orderId);
Assert.AreEqual(1, list.Count());
var dto = list.Single();
Assert.AreEqual(accountId, dto.AccountId);
Assert.AreEqual("3939", dto.PickupAddress.Apartment);
Assert.AreEqual("1234 rue Saint-Hubert", dto.PickupAddress.Street);
Assert.AreEqual("3131", dto.PickupAddress.RingCode);
Assert.AreEqual(45.515065, dto.PickupAddress.Latitude);
Assert.AreEqual(-73.558064, dto.PickupAddress.Longitude);
Assert.AreEqual("Velvet auberge st gabriel", dto.DropOffAddress.FriendlyName);
Assert.AreEqual(45.50643, dto.DropOffAddress.Latitude);
Assert.AreEqual(-73.554052, dto.DropOffAddress.Longitude);
Assert.AreEqual(pickupDate.ToLongDateString(), dto.PickupDate.ToLongDateString());
Assert.AreEqual("fr", dto.ClientLanguageCode);
Assert.AreEqual("TestUserAgent", dto.UserAgent);
Assert.AreEqual("1.0.0", dto.ClientVersion);
Assert.AreEqual("une note", dto.UserNote);
Assert.AreEqual(5, dto.BookingFees);
Assert.AreEqual("MTL", dto.Market);
Assert.AreEqual("Kramerica", dto.CompanyKey);
Assert.AreEqual("Kramerica Industries", dto.CompanyName);
Assert.AreEqual(50.5, dto.EstimatedFare);
Assert.AreEqual("192.168.12.30", dto.OriginatingIpAddress);
Assert.AreEqual("1i3u13n123", dto.KountSessionId);
//Settings
Assert.AreEqual(99, dto.Settings.ChargeTypeId);
Assert.AreEqual(98, dto.Settings.VehicleTypeId);
Assert.AreEqual(97, dto.Settings.ProviderId);
Assert.AreEqual(96, dto.Settings.NumberOfTaxi);
Assert.AreEqual(95, dto.Settings.Passengers);
Assert.AreEqual("94", dto.Settings.Phone);
Assert.AreEqual("93", dto.Settings.Name);
Assert.AreEqual(92, dto.Settings.LargeBags);
Assert.AreEqual("account", dto.Settings.AccountNumber);
Assert.AreEqual("customer", dto.Settings.CustomerNumber);
Assert.AreEqual("123", dto.Settings.PayBack);
}
}
public async Task Should_throw_exception_if_source_file_name_to_copy_is_empty()
{
await CheckEmpty(v => Sut.CopyAsync(v, "Target"));
}
public async Task Should_throw_exception_if_file_name_to_delete_is_empty()
{
await CheckEmpty(v => Sut.DeleteAsync(v));
}
public void IssueProxyIsCreated()
{
IIssue issue = Sut.CreateIssue(IssueId, Mock <IConnection>());
Assert.That(issue.GetType().Name, Is.EqualTo("IIssueProxy"));
}
public async Task Should_throw_exception_if_asset_to_copy_is_not_found()
{
await Assert.ThrowsAsync <AssetNotFoundException>(() => Sut.CopyAsync(fileName, sourceFile));
}
public async Task ReturnsData(Dictionary <string, object> dictionary, Guid organizationId, Guid userId, Guid providerDefinitionId)
{
Assert.NotNull(
await Sut.GetCrawlJobData(_context, dictionary, organizationId, userId, providerDefinitionId));
}
public async Task ServiceNowCrawlJobDataReturned(Dictionary <string, object> dictionary, Guid organizationId, Guid userId, Guid providerDefinitionId)
{
Assert.IsType <CluedIn.Crawling.ServiceNow.Core.ServiceNowCrawlJobData>(
await Sut.GetCrawlJobData(_context, dictionary, organizationId, userId, providerDefinitionId));
}
private void Validate_Return_Value()
{
Sut.Validate(_mockRacingCards.Object);
_mockRacingCards.Verify(x => x.AllCardAreTheSameAnimal(), Times.Once);
}
public override void Act()
{
Sut.Decrease();
}
public void then_wait_returns_success()
{
Sut.WaitUntil(0, TimeSpan.FromSeconds(1)).Should().BeTrue();
}
public override void Act()
{
Task.Factory.StartNew(() => Sut.WaitUntil(0, TimeSpan.FromMinutes(1)));
Thread.Sleep(100);
}
public void IssueIdIsAssigned()
{
IIssue issue = Sut.CreateIssue(IssueId, Mock <IConnection>());
Assert.That(issue.Id, Is.EqualTo(IssueId));
}
public virtual async Task Should_throw_exception_if_asset_to_download_is_not_found()
{
await Assert.ThrowsAsync <AssetNotFoundException>(() => Sut.DownloadAsync(fileName, new MemoryStream()));
}
public void ItShouldReturnAnInstanceOfARegisteredObject()
{
Sut.GetInstance(typeof(IContract)).Should().BeOfType <Provider>();
}
public async Task Should_throw_exception_if_stream_to_upload_is_null()
{
await Assert.ThrowsAsync <ArgumentNullException>(() => Sut.UploadAsync("File", null !));
}
public void then_next_decrease_is_not_blocked()
{
Sut.Decrease();
}
public async Task Should_throw_exception_if_target_file_name_to_copy_is_empty()
{
await CheckEmpty(v => Sut.CopyAsync("Source", v));
}
public void DataLibrarian_GetAllGames_ReturnsGames()
{
var result = Sut.GetAllGames(season: 2018);
Assert.IsTrue(result.Tables["SCHED"].Rows.Count > 0);
}
public async Task Should_throw_exception_if_file_name_to_upload_is_empty()
{
await CheckEmpty(v => Sut.UploadAsync(v, new MemoryStream()));
}
protected override void Because()
{
Sut.ValidateModel(Model);
}
protected override void Act()
{
Sut.Inject();
}
public void Returns_ValidDictionary_Instance(Guid organizationId, Guid userId, Guid providerDefinitionId)
{
Sut.GetHelperConfiguration(null, _jobData, organizationId, userId, providerDefinitionId)
.Result
.ShouldNotBeNull();
}
public async void GivenSomeAsyncSetup()
{
_sut = await CreateSut();
}
public async Task Should_throw_exception_when_file_to_write_already_exists()
{
await Sut.UploadAsync(fileName, assetSmall);
await Assert.ThrowsAsync <AssetAlreadyExistsException>(() => Sut.UploadAsync(fileName, assetSmall));
}
protected override void Act()
{
Returned = Sut.Extract(Code);
}
public virtual async Task Should_throw_exception_if_asset_to_get_size_is_not_found()
{
await Assert.ThrowsAsync <AssetNotFoundException>(() => Sut.GetSizeAsync(fileName));
}
public void ItShouldReturnAllInstances()
{
Sut.GetAllInstances(typeof(IContract)).Should()
.OnlyContain(o => o.GetType() == typeof(Provider))
.And.HaveCount(1);
}
public void then_next_increase_is_not_blocked()
{
Sut.Increase();
}
