public async Task Posting_command_JSON_applies_a_command_with_the_specified_name_to_an_aggregate_with_the_specified_id()
{
var order = new Order(Guid.NewGuid(),
new Order.CustomerInfoChanged { CustomerName = "Joe" });
await order.SaveToEventStore();
var json = new AddItem
{
Quantity = 5,
Price = 19.99m,
ProductName = "Bag o' Treats"
}.ToJson();
var request = new HttpRequestMessage(HttpMethod.Post, string.Format("http://contoso.com/orders/{0}/additem", order.Id))
{
Content = new StringContent(json, Encoding.UTF8, "application/json")
};
var testApi = new TestApi<Order>();
var client = testApi.GetClient();
var response = client.SendAsync(request).Result;
response.StatusCode.Should().Be(HttpStatusCode.OK);
var updatedOrder = await new SqlEventSourcedRepository<Order>().GetLatest(order.Id);
updatedOrder.Items.Single().Quantity.Should().Be(5);
}
public static Selection convertToSelection(this AddItem item)
{
switch (item)
{
case AddItem.Measure:
return(Selection.Add_Measure);
case AddItem.Rest:
return(Selection.Add_Rest);
case AddItem.Note:
return(Selection.Add_Note);
case AddItem.PalmMute:
case AddItem.Bend:
case AddItem.PinchHarmonic:
case AddItem.Vibrato:
return(Selection.Add_Effect);
case AddItem.Slide:
case AddItem.Hopo:
case AddItem.Tie:
return(Selection.Add_Multi_Effect);
case AddItem.Length:
return(Selection.Set_Length);
default:
return(Selection.Standard);
}
}
public async Task AddProduct(AddItem request, byte[] image)
{
//if (request.Sizes.Length != request.Quantities.Length)
//throw new Exception("Массивы размеров и их количеств не совпадают!");
var product = await _dbContext.Product.AddAsync(new Product
{
VendorCode = request.VendorCode,
Name = request.Name,
Price = request.Price,
Description = request.Description,
Gender = request.Gender,
Category = request.Category,
Brand = request.Brand,
Color = request.Color,
Image = image
});
await _dbContext.SaveChangesAsync();
for (var i = 0; i < request.Sizes.Length; i++)
{
if (request.Quantities[i] > 0)
{
await _dbContext.ProductSize.AddAsync(new ProductSize
{
ProductId = product.Entity.Id,
Size = request.Sizes[i],
Quantity = request.Quantities[i]
});
}
}
await _dbContext.SaveChangesAsync();
}
public SaleViewModel()
{
Items = new BindableCollection <ItemViewModel>();
IsToolVisible = false;
PaymentForms = new BindableCollection <AmountItemViewModel>();
var pco = Observable.FromEventPattern <PropertyChangedEventArgs>(this, "PropertyChanged")
.Select(x => x.EventArgs)
.Where(x => x.PropertyName == "ViewState")
.Select(x => this.ViewState);
var normal = pco.Where(x => x == "Normal").Select(x => Unit.Default);
var other = pco.Where(x => x != "Normal").Select(x => Unit.Default);
Scanner.ObservableKeys
.Where(x => !char.IsWhiteSpace(x))
.SkipUntil(normal)
.Publish(o => o.Buffer(() => o.Throttle(TimeSpan.FromMilliseconds(500))))
.Select(x => string.Join("", x))
.TakeUntil(other)
.Repeat()
.Subscribe(x =>
{
AddItem["kodi"] = x;
AddItem.Execute(null);
});
}
// Use this for initialization
void Start()
{
if (Application.isEditor)
{
C_Stats.ACT = 1f;
}
else if (Application.isMobilePlatform)
{
C_Stats.ACT = 1.0f;
ChatGUI.addLine("MobilePlatform Spotted!");
}
Get = this;
ChatGUI.addLine("This Is The Path for Textures!");
ChatGUI.addLine("Put Textures folder in there, then reload everything to implement the change!");
ChatGUI.addLine(Application.persistentDataPath);
ItemCreator = new ITEMS();
ITEMS.main = ItemCreator;
ItemCreator.ADDITEMS();
ITEMS.main.CreateStatEnchanter(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, " Range_Enchanter", AgilityIcon);
//ITEMS.main.CreateStatEnchanter(0,55,0,0,0,0,0,0,0,0,0,3,0, " Rang2", AgilityIcon);
//ITEMS.main.CreateStatEnchanter(0,0,55,0,0,0,0,0,0,0,0,3,0, " Rang3r", AgilityIcon);
Add_items = add;
les = GetComponent <LoadExternalAsSprite>();
StartCoroutine(load_items());
}
public void Nested_command_contexts_maintain_independent_etag_sequences()
{
// arrange
var target = Any.Guid().ToString();
var outerCommand = new AddItem
{
ETag = Any.Word()
};
var expectedSequence = new List <string>();
var sequence2 = new List <string>();
using (var outerCtx = CommandContext.Establish(outerCommand))
{
Enumerable.Range(1, 10).ForEach(_ => expectedSequence.Add(outerCtx.NextETag(target)));
}
// act
using (var outerCtx = CommandContext.Establish(outerCommand))
{
Enumerable.Range(1, 5).ForEach(_ => sequence2.Add(outerCtx.NextETag(target)));
using (var innerCtx = CommandContext.Establish(new AddItem()))
{
Console.WriteLine(innerCtx.NextETag(Any.Word()));
}
Enumerable.Range(1, 5).ForEach(_ => sequence2.Add(outerCtx.NextETag(target)));
}
// assert
sequence2.Should().Equal(expectedSequence);
}
protected override void OnAppearing()
{
base.OnAppearing();
ListView.ItemSelected += FolderSelected;
AddItem?.InitEvents();
LoadFoldersAsync().Wait();
}
void Add()
{
AddItem addItem = new AddItem();
addItem.DataContext = new AddItemViewModel(_Items, addItem);
addItem.ShowDialog();
}
protected static async Task ScheduleCommandAgainstEventSourcedAggregate(
string targetId,
string etag,
DateTimeOffset?dueTime = null,
IPrecondition deliveryDependsOn = null)
{
var aggregateId = Guid.Parse(targetId);
var repository = Configuration.Current.Repository <Order>();
if (await repository.GetLatest(aggregateId) == null)
{
await repository.Save(new Order(new CreateOrder(Any.FullName())
{
AggregateId = aggregateId
}));
}
var command = new AddItem
{
ETag = etag,
ProductName = Any.Word(),
Price = 10m
};
var scheduledCommand = new ScheduledCommand <Order>(
command,
aggregateId,
dueTime,
deliveryDependsOn);
var scheduler = Configuration.Current.CommandScheduler <Order>();
await scheduler.Schedule(scheduledCommand);
}
private void jDataTreeView1_SelectedItemChange(object sender, TreeViewEventArgs e)
{
ClearBackColor();
_exp = " 1=1 ";
SelectedItem = (DataRow)(((System.Windows.Forms.TreeNode)jDataTreeView1.SelectedItem).Tag);
if (SelectedItem != null)
{
if ((((System.Data.DataRow)(((System.Windows.Forms.TreeNode)(jDataTreeView1.SelectedItem)).Tag)).ItemArray[0] != null) && (((System.Data.DataRow)(((System.Windows.Forms.TreeNode)(jDataTreeView1.SelectedItem)).Tag)).ItemArray[0].ToString()) != "-1")
{
if ((((System.Data.DataRow)(((System.Windows.Forms.TreeNode)(jDataTreeView1.SelectedItem)).Tag)).ItemArray[8] != null) && (((System.Data.DataRow)(((System.Windows.Forms.TreeNode)(jDataTreeView1.SelectedItem)).Tag)).ItemArray[8].ToString()) != "")
{
_exp = _exp + " And " + JTableNamesAutomation.Objects + "." + Objects.objecttype + "=" + ((System.Data.DataRow)(((System.Windows.Forms.TreeNode)(jDataTreeView1.SelectedItem)).Tag)).ItemArray[8].ToString();
}
if ((((System.Data.DataRow)(((System.Windows.Forms.TreeNode)(jDataTreeView1.SelectedItem)).Tag)).ItemArray[8] != null) && (((System.Data.DataRow)(((System.Windows.Forms.TreeNode)(jDataTreeView1.SelectedItem)).Tag)).ItemArray[7].ToString()) != "")
{
_exp = _exp + " And " + JTableNamesAutomation.Refer + "." + Refer.sender_post_code + "=" + ((System.Data.DataRow)(((System.Windows.Forms.TreeNode)(jDataTreeView1.SelectedItem)).Tag)).ItemArray[7].ToString();
}
}
AddItem degAddToList = new AddItem(FilldgCentral);
this.Invoke(degAddToList, _exp);
//test();
//dgCentral.Bind(Filldt(tmprefer.FindReferBycodepostObject(Convert.ToInt32(((DataRowView)(LbPost.SelectedItem))["code"]), _user_code, Convert.ToInt32(cmbObjectType.SelectedValue))), JJanusGrid.JSettingKeys.Central);
}
}
public void TestAddItem()
{
AddItem req;
Request req2;
RecombeeBinding resp;
// it 'does not fail with valid entity id'
req = new AddItem("valid_id");
resp = client.Send(req);
// it 'fails with invalid entity id'
req = new AddItem("$$$not_valid$$$");
try
{
client.Send(req);
Assert.True(false, "No exception thrown");
}
catch (ResponseException ex)
{
Assert.Equal(400, (int)ex.StatusCode);
}
// it 'really stores entity to the system'
req = new AddItem("valid_id2");
resp = client.Send(req);
try
{
client.Send(req);
Assert.True(false, "No exception thrown");
}
catch (ResponseException ex)
{
Assert.Equal(409, (int)ex.StatusCode);
}
}
public static EffectType convertToEffectType(this AddItem item)
{
switch (item)
{
case AddItem.PalmMute:
return(EffectType.Palm_Mute);
case AddItem.Bend:
return(EffectType.Bend);
case AddItem.PinchHarmonic:
return(EffectType.Pinch_Harmonic);
case AddItem.Vibrato:
return(EffectType.Vibrato);
case AddItem.Slide:
return(EffectType.Slide);
case AddItem.Hopo:
return(EffectType.HOPO);
case AddItem.Tie:
return(EffectType.Tie);
default:
return(EffectType.No_Type);
}
}
public async void TestInsertToSeriesAsync()
{
InsertToSeries req;
Request req2;
RecombeeBinding resp;
// it 'does not fail when inserting existing item into existing set'
req2 = new AddItem("new_item");
await client.SendAsync(req2);
req = new InsertToSeries("entity_id", "item", "new_item", 3);
resp = await client.SendAsync(req);
// it 'does not fail when cascadeCreate is used'
req = new InsertToSeries("new_set", "item", "new_item2", 1, cascadeCreate: true);
resp = await client.SendAsync(req);
// it 'really inserts item to the set'
req2 = new AddItem("new_item3");
await client.SendAsync(req2);
req = new InsertToSeries("entity_id", "item", "new_item3", 2);
resp = await client.SendAsync(req);
try
{
await client.SendAsync(req);
Assert.True(false, "No exception thrown");
}
catch (ResponseException ex)
{
Assert.Equal(409, (int)ex.StatusCode);
}
}
private void Button_Click_10(object sender, RoutedEventArgs e)
{
AddItem add = new AddItem();
add.Show();
this.Close();
}
public void AddItem_Equals_WithDifferentKey_ReturnsFalse()
{
var add1 = new AddItem("key1", "value1");
var add2 = new AddItem("keyN", "value1");
add1.Equals(add2).Should().BeFalse();
}
private void addBtn_Click(object sender, RoutedEventArgs e)
{
AddItem componentTree = null;
if (selectedUIComponentID != null)
{
componentTree = components.FirstOrDefault(x => x.ID == selectedUIComponentID).ComponentTree;
if (!(componentTree is AddSecureItem))
{
components.FirstOrDefault(x => x.ID == selectedUIComponentID).ExecuteCommand("AddItem", null);
return;
}
}
AddItemChildWindow addChildWindow = new AddItemChildWindow(AddItemsList, componentTree);
bool?dialogResult = addChildWindow.ShowDialog();
if (dialogResult.Value)
{
var c = resolver.GetAllInstancesOf <IUIComponent>().FirstOrDefault(i => i.ID == addChildWindow.SelectedItemType.ComponentId);
if (c == null)
{
return;
}
// var p = new Dictionary<string, object>();
if (addChildWindow.SelectedItemType is AddSecureItem)
{
var add = Application.Current.Resources["Add"] as string;
if (addChildWindow.SelectedSubItemType.CreateItemType == null)
{
return;
}
var secureItem = Activator.CreateInstance(addChildWindow.SelectedSubItemType.CreateItemType) as ISecureItemVM;
secureItem.ItemTitel = add + " " + addChildWindow.SelectedSubItemType.ItemTitel;
secureItem.FoldersList = pbData.GetFoldersBySecureItemType();
secureItem.Background = addChildWindow.SelectedSubItemType.BackgoundColor;
secureItem.Image = ((BitmapImage)addChildWindow.SelectedSubItemType.Icon).ToString();
secureItem.AddNewFolder_Clicked += (o, arg) =>
{
var folder = ServiceLocator.Get <IFolderService>().AddFolder();
if (!string.IsNullOrEmpty(folder))
{
secureItem.FoldersList = pbData.GetFoldersBySecureItemType();
secureItem.Folder = secureItem.FoldersList.FirstOrDefault(x => x.UUID == folder);
}
;
};
//p.Add("item", secureItem);
if (c.ViewModel is ISecureHolder)
{
((ISecureHolder)c.ViewModel).AddNewItem(secureItem);
}
}
//c.ExecuteCommand("AddItem", p);
}
}
private void edit_Button_Click(object sender, EventArgs e)
{
var eForm = new AddItem(EditBook, GetSelectedValue(NameA), GetSelectedValue(Author), GetSelectedValue(Publisher),
int.Parse(GetSelectedValue(Year)), int.Parse(GetSelectedValue(Id)), int.Parse(GetSelectedValue(IdPub)), true);
eForm.Show();
}
// Use this for initialization
void Start()
{
ai = AddItem.instance;
rc = RoomsControls.instance;
ic = ItemsControls.instance;
// Store pages in dictionary
Pages = new Dictionary <string, GameObject>();
Pages.Add("Summary", GameObject.FindWithTag("Summary"));
Pages.Add("Rooms", GameObject.FindWithTag("Rooms"));
Pages.Add("AddRoom", GameObject.FindWithTag("AddRoom"));
Pages.Add("Items", GameObject.FindWithTag("Items"));
Pages.Add("AddItem", GameObject.FindWithTag("AddItem"));
Pages.Add("Receipts", GameObject.FindWithTag("Receipts"));
Pages.Add("Settings", GameObject.FindWithTag("Settings"));
InterfaceColour = new Color(0.27f, 0.72f, 1.0f);
CurrentPage = Page.Summary;
ChangePage(CurrentPage);
// Make some dummy data for the start
Rooms = new Dictionary <string, Room>();
Room temp = new Room("Living room", "", RoomType.LivingSpace);
temp.AddItem(new Item("Table", 75.0f, "Living room", ItemCategory.Furniture, ""));
Rooms.Add(temp.ObjName, temp);
temp = new Room("Kitchen", "", RoomType.Kitchen);
temp.AddItem(new Item("Spaghetti", 13.5f, "Kitchen", ItemCategory.Spaghetti, ""));
Rooms.Add(temp.ObjName, temp);
}
public void AddItem_SingleTag_WithOnlyKeyAndValue_ParsedSuccessfully()
{
// Arrange
var nugetConfigPath = "NuGet.Config";
var config = @"
<configuration>
<Section>
<add key='key1' value='value1' />
</Section>
</configuration>";
var expectedSetting = new AddItem("key1", "value1");
using (var mockBaseDirectory = TestDirectory.Create())
{
SettingsTestUtils.CreateConfigurationFile(nugetConfigPath, mockBaseDirectory, config);
var settingsFile = new SettingsFile(mockBaseDirectory);
// Act
var section = settingsFile.GetSection("Section");
section.Should().NotBeNull();
var element = section.Items.FirstOrDefault() as AddItem;
element.Should().NotBeNull();
// Assert
SettingsTestUtils.DeepEquals(element, expectedSetting).Should().BeTrue();
}
}
public void AddNewItemWithSemicolon()
{
// ************************************
// BEFORE
// ************************************
string projectOriginalContents = @"
<Project ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<ItemGroup>
<MyWildCard Include=`*.weirdo`/>
</ItemGroup>
</Project>
";
// ************************************
// AFTER
// ************************************
string projectNewExpectedContents = @"
<Project ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<ItemGroup>
<MyWildCard Include=`*.weirdo`/>
<MyWildCard Include=`foo;bar.weirdo`/>
</ItemGroup>
</Project>
";
BuildItem newItem = AddItem.AddNewItemHelper(projectOriginalContents,
projectNewExpectedContents, "MyWildCard", "foo;bar.weirdo");
Assertion.AssertEquals("Newly added item should have correct ItemName", "MyWildCard", newItem.Name);
Assertion.AssertEquals("Newly added item should have correct Include", "foo;bar.weirdo", newItem.Include);
}
/// <summary>
/// Raises event 'AddItem'
/// </summary>
protected virtual void OnAddItem()
{
if (AddItem != null)
{
AddItem.Invoke(this, System.EventArgs.Empty);
}
}
public void The_clock_set_in_the_CommandContext_is_used_by_resulting_events()
{
var created = DateTimeOffset.Parse("2014-05-15 00:00:00");
var addItem = new AddItem
{
ProductName = "Widget",
Price = 3.99m
};
Order order;
using (CommandContext.Establish(addItem, Clock.Create(() => created)))
{
order = new Order(new CreateOrder(Any.FullName()));
order.Apply(addItem);
}
order.Events()
.Count()
.Should()
.Be(3);
order.Events()
.Should()
.OnlyContain(e => e.Timestamp == created);
}
public void AddItem_WithAdditionalMetada_ParsedSuccessfully()
{
// Arrange
var nugetConfigPath = "NuGet.Config";
var config = @"
<configuration>
<Section>
<add key='key1' value='value1' meta1='data1' meta2='data2'/>
</Section>
</configuration>";
var expectedSetting = new AddItem("key1", "value1",
new ReadOnlyDictionary <string, string>(new Dictionary <string, string> {
{ "meta1", "data1" },
{ "meta2", "data2" }
}));
using (var mockBaseDirectory = TestDirectory.Create())
{
SettingsTestUtils.CreateConfigurationFile(nugetConfigPath, mockBaseDirectory, config);
var settingsFile = new SettingsFile(mockBaseDirectory);
// Act
var section = settingsFile.GetSection("Section");
section.Should().NotBeNull();
var value = section.Items.FirstOrDefault() as AddItem;
value.Should().NotBeNull();
// Assert
SettingsTestUtils.DeepEquals(value, expectedSetting).Should().BeTrue();
}
}
/// <summary>
///
/// </summary>
private void BtnModifyItemClickEvent()
{
if (SelectedIndex < 0)
{
MessageBox.Show("Please make a selection into list!", Constants.ProjectTitle);
return;
}
AddItem = new AddItem();
AddItem.ApplicationName = Constants.ViewNames.ModifyItem;
AddItem.ProcessFrom = Constants.ViewNames.ModifyItem;
AddItem.Vm.ProcessFrom = Constants.ViewNames.ModifyItem;
AddItem.txtparentworkspace.IsEnabled = false;
AddItem.btnsearch.IsEnabled = false;
AddItem.workspacetypecombo.IsEnabled = false;
AddItem.Workspacetext.IsEnabled = false;
AddItem.addimage.IsEnabled = false;
AddItem.txtOI.IsEnabled = false;
AddItem.Vm.WorkspaceItemProperties = WorkspaceItemProperties;
AddItem.WorkspaceItemProperties = WorkspaceItemProperties;
AddItem.Vm.CurrentItem = SelectedItem;
AddItem.Vm.DescriptionListItem = DescriptionListItem;
AddItem.DescriptionListItem = DescriptionListItem;
AddItem.ShowDialog();
EventBroker.RaiseGetId(new LoadWorkspaceItemEventArgs()
{
ItemId = SelectedItem.ItemId
});
}
public async Task Posting_command_JSON_applies_a_command_with_the_specified_name_to_an_aggregate_with_the_specified_id()
{
var order = new Order(Guid.NewGuid())
.Apply(new ChangeCustomerInfo {
CustomerName = "Joe"
})
.SavedToEventStore();
var json = new AddItem
{
Quantity = 5,
Price = 19.99m,
ProductName = "Bag o' Treats"
}.ToJson();
var request = new HttpRequestMessage(HttpMethod.Post, $"http://contoso.com/orders/{order.Id}/additem")
{
Content = new StringContent(json, Encoding.UTF8, "application/json")
};
var testApi = new TestApi <Order>();
var client = testApi.GetClient();
var response = client.SendAsync(request).Result;
response.StatusCode.Should().Be(HttpStatusCode.OK);
var updatedOrder = await Configuration.Current.Repository <Order>().GetLatest(order.Id);
updatedOrder.Items.Single().Quantity.Should().Be(5);
}
public async Task Posting_an_invalid_command_does_not_affect_the_aggregate_state()
{
var order = new Order(Guid.NewGuid(),
new Order.CustomerInfoChanged {
CustomerName = "Joe"
},
new Order.Fulfilled());
await order.SaveToEventStore();
var json = new AddItem
{
Quantity = 5,
Price = 19.99m,
ProductName = "Bag o' Treats"
}.ToJson();
var request = new HttpRequestMessage(HttpMethod.Post, string.Format("http://contoso.com/orders/{0}/additem", order.Id))
{
Content = new StringContent(json, Encoding.UTF8, "application/json")
};
var testApi = new TestApi <Order>();
var client = testApi.GetClient();
var response = client.SendAsync(request).Result;
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
var updatedOrder = await new SqlEventSourcedRepository <Order>().GetLatest(order.Id);
updatedOrder.Items.Count().Should().Be(0);
}
protected virtual void INPIClass_RowSelected(PXCache sender, PXRowSelectedEventArgs e)
{
INPIClass row = e.Row as INPIClass;
if (row == null)
{
return;
}
PXUIFieldAttribute.SetVisible <INPIClass.lastCountPeriod>(sender, row, row.SelectedMethod == PIInventoryMethod.LastCountDate);
PXUIFieldAttribute.SetVisible <INPIClass.randomItemsLimit>(sender, row, row.SelectedMethod == PIInventoryMethod.RandomlySelectedItems);
PXUIFieldAttribute.SetEnabled <INPIClass.aBCCodeID>(sender, row, row.ByFrequency != true);
PXUIFieldAttribute.SetEnabled <INPIClass.movementClassID>(sender, row, row.ByFrequency != true);
PXUIFieldAttribute.SetEnabled <INPIClass.cycleID>(sender, row, row.ByFrequency != true);
this.Items.Cache.AllowInsert =
this.Items.Cache.AllowUpdate =
this.Items.Cache.AllowDelete =
row.SelectedMethod == PIInventoryMethod.ListOfItems;
AddItem.SetEnabled(row.SelectedMethod == PIInventoryMethod.ListOfItems);
this.Locations.Cache.AllowInsert =
this.Locations.Cache.AllowUpdate =
this.Locations.Cache.AllowDelete =
row.SiteID != null;
}
public async Task Posting_an_invalid_command_does_not_affect_the_aggregate_state()
{
var order = new Order(Guid.NewGuid())
.Apply(new ChangeCustomerInfo { CustomerName = "Joe" })
.Apply(new Deliver())
.SavedToEventStore();
var json = new AddItem
{
Quantity = 5,
Price = 19.99m,
ProductName = "Bag o' Treats"
}.ToJson();
var request = new HttpRequestMessage(HttpMethod.Post, $"http://contoso.com/orders/{order.Id}/additem")
{
Content = new StringContent(json, Encoding.UTF8, "application/json")
};
var testApi = new TestApi<Order>();
var client = testApi.GetClient();
var response = client.SendAsync(request).Result;
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
var updatedOrder = await Configuration.Current.Repository<Order>().GetLatest(order.Id);
updatedOrder.Items.Count.Should().Be(0);
}
public AddItemViewModel(AddItem addItem)
{
_addItem = addItem;
_posRepository = SettingHelpers.GetRepositoryImplementation();
Barcode = SettingHelpers.CurrentBarcode;
GetUnitTypeList();
}
public void The_clock_set_in_the_CommandContext_is_used_by_resulting_events()
{
var created = DateTimeOffset.Parse("2014-05-15 00:00:00");
var addItem = new AddItem
{
ProductName = "Widget",
Price = 3.99m,
};
Order order;
using (CommandContext.Establish(addItem, Clock.Create(() => created)))
{
order = new Order(new CreateOrder(Any.FullName()));
order.Apply(addItem);
}
order.Events()
.Count()
.Should()
.Be(3);
order.Events()
.Should()
.OnlyContain(e => e.Timestamp == created);
}
private void buttonX1_Click(object sender, EventArgs e)
{
senderItem = InputItem;
AddShipment shipment = new AddShipment();
shipment.ShowDialog();
}
public void SourceItem_CaseInsensitive_ParsedSuccessfully()
{
// Arrange
var config = @"
<configuration>
<section>
<AdD key='key' value='val' />
</section>
</configuration>";
var expectedValue = new AddItem("key", "val");
var nugetConfigPath = "NuGet.Config";
using (var mockBaseDirectory = TestDirectory.Create())
{
SettingsTestUtils.CreateConfigurationFile(nugetConfigPath, mockBaseDirectory, config);
// Act and Assert
var settingsFile = new SettingsFile(mockBaseDirectory);
settingsFile.Should().NotBeNull();
var section = settingsFile.GetSection("section");
section.Should().NotBeNull();
var children = section.Items.ToList();
children.Should().NotBeEmpty();
children.Count.Should().Be(1);
SettingsTestUtils.DeepEquals(children[0], expectedValue).Should().BeTrue();
}
}
public void AddNewItemThatMatchesWildcard2()
{
// ************************************
// BEFORE
// ************************************
string projectOriginalContents = @"
<Project ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<ItemGroup>
<MyWildCard Include=`*.AAA%253bBBB`/>
</ItemGroup>
</Project>
";
// ************************************
// AFTER
// ************************************
string projectNewExpectedContents = @"
<Project ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<ItemGroup>
<MyWildCard Include=`*.AAA%253bBBB`/>
</ItemGroup>
</Project>
";
BuildItem newItem = AddItem.AddNewItemHelper(projectOriginalContents,
projectNewExpectedContents, "MyWildCard", "foobar.AAA%253bBBB");
Assertion.AssertEquals("Newly added item should have correct ItemName", "MyWildCard", newItem.Name);
Assertion.AssertEquals("Newly added item should have correct Include", "*.AAA%253bBBB", newItem.Include);
Assertion.AssertEquals("Newly added item should have correct FinalItemSpec", "foobar.AAA%253bBBB", newItem.FinalItemSpecEscaped);
Assertion.AssertEquals("Newly added item should have correct FinalItemSpec", "foobar.AAA%3bBBB", newItem.FinalItemSpec);
}
public async Task When_a_command_is_delivered_a_second_time_with_the_same_ETag_it_is_not_retried_afterward()
{
// arrange
var order = new Order(new CreateOrder(Any.FullName())
{
CustomerId = Any.Guid()
});
await orderRepository.Save(order);
var command = new AddItem
{
ProductName = Any.Word(),
Price = 10m,
ETag = Any.Guid().ToString()
};
var commandScheduler = Configuration.Current.Container.Resolve<ICommandScheduler<Order>>();
// act
await commandScheduler.Schedule(order.Id, command, Clock.Now().AddDays(1));
Thread.Sleep(1); // the sequence number is set from the current tick count, which every now and then produces a duplicate here
await commandScheduler.Schedule(order.Id, command, Clock.Now().AddDays(1));
await clockTrigger.Trigger(cmd => cmd.Where(c => c.AggregateId == order.Id));
// assert
order = await orderRepository.GetLatest(order.Id);
order.Balance.Should().Be(10);
using (var db = new CommandSchedulerDbContext())
{
db.ScheduledCommands
.Where(c => c.AggregateId == order.Id)
.Should()
.OnlyContain(c => c.AppliedTime != null);
db.Errors
.Where(c => c.ScheduledCommand.AggregateId == order.Id)
.Should()
.BeEmpty();
}
}
protected static async Task ScheduleCommandAgainstEventSourcedAggregate(
string targetId,
string etag,
DateTimeOffset? dueTime = null,
IPrecondition deliveryDependsOn = null)
{
var aggregateId = Guid.Parse(targetId);
var repository = Configuration.Current.Repository<Order>();
if (await repository.GetLatest(aggregateId) == null)
{
await repository.Save(new Order(new CreateOrder(Any.FullName())
{
AggregateId = aggregateId
}));
}
var command = new AddItem
{
ETag = etag,
ProductName = Any.Word(),
Price = 10m
};
var scheduledCommand = new ScheduledCommand<Order>(
command,
aggregateId,
dueTime,
deliveryDependsOn);
var scheduler = Configuration.Current.CommandScheduler<Order>();
await scheduler.Schedule(scheduledCommand);
}
public void Nested_command_contexts_maintain_independent_etag_sequences()
{
// arrange
var target = Any.Guid().ToString();
var outerCommand = new AddItem
{
ETag = Any.Word()
};
var expectedSequence = new List<string>();
var sequence2 = new List<string>();
using (var outerCtx = CommandContext.Establish(outerCommand))
{
Enumerable.Range(1, 10).ForEach(_ => expectedSequence.Add(outerCtx.NextETag(target)));
}
// act
using (var outerCtx = CommandContext.Establish(outerCommand))
{
Enumerable.Range(1, 5).ForEach(_ => sequence2.Add(outerCtx.NextETag(target)));
using (var innerCtx = CommandContext.Establish(new AddItem()))
{
Console.WriteLine(innerCtx.NextETag(Any.Word()));
}
Enumerable.Range(1, 5).ForEach(_ => sequence2.Add(outerCtx.NextETag(target)));
}
// assert
sequence2.Should().Equal(expectedSequence);
}
public async Task NextETag_returns_a_different_value_each_time()
{
var target = Any.Guid().ToString();
var command = new AddItem
{
ETag = Any.Word()
};
var etags = new HashSet<string>();
using (var ctx = CommandContext.Establish(command))
{
Enumerable.Range(1, 100).ForEach(_ => etags.Add(ctx.NextETag(target)));
}
etags.Count().Should().Be(100);
}
public async Task When_a_command_is_delivered_a_second_time_with_the_same_ETag_it_is_not_retried_afterward()
{
// arrange
var order = new Order(new CreateOrder(Any.FullName())
{
CustomerId = Any.Guid()
});
await Save(order);
var command = new AddItem
{
ProductName = Any.Word(),
Price = 10m,
ETag = Any.Guid().ToString()
};
// act
var scheduledCommand = await Schedule(order.Id, command, Clock.Now().AddDays(1));
var deliverer = Configuration
.Current
.CommandDeliverer<Order>();
await deliverer.Deliver(scheduledCommand);
await deliverer.Deliver(scheduledCommand);
// assert
order = await Get<Order>(order.Id);
order.Balance.Should().Be(10);
using (var db = CommandSchedulerDbContext())
{
db.ScheduledCommands
.Where(c => c.AggregateId == order.Id)
.Should()
.OnlyContain(c => c.AppliedTime != null);
db.Errors
.Where(c => c.ScheduledCommand.AggregateId == order.Id)
.Should()
.BeEmpty();
}
}
public void A_series_of_calls_to_NextETag_produces_a_different_etag_per_call()
{
var target = Any.Guid().ToString();
var command = new AddItem
{
ETag = Any.Word()
};
var sequence = new List<string>();
using (var ctx = CommandContext.Establish(command))
{
Enumerable.Range(1, 10).ForEach(_ => sequence.Add(ctx.NextETag(target)));
}
sequence.Distinct().Should().HaveCount(10);
}
public async Task An_ETag_header_is_applied_to_the_command()
{
var order = new Order(Guid.NewGuid())
.Apply(new ChangeCustomerInfo { CustomerName = "Joe" })
.SavedToEventStore();
var json = new AddItem
{
Quantity = 5,
Price = 19.99m,
ProductName = "Bag o' Treats"
}.ToJson();
var etag = new EntityTagHeaderValue("\"" + Any.Guid() + "\"");
Func<HttpRequestMessage> createRequest = () =>
{
var request = new HttpRequestMessage(HttpMethod.Post, $"http://contoso.com/orders/{order.Id}/additem")
{
Content = new StringContent(json, Encoding.UTF8, "application/json")
};
request.Headers.IfNoneMatch.Add(etag);
return request;
};
var testApi = new TestApi<Order>();
var client = testApi.GetClient();
// act: send the request twice
var response1 = await client.SendAsync(createRequest());
var response2 = await client.SendAsync(createRequest());
// assert
response1.ShouldSucceed(HttpStatusCode.OK);
response2.ShouldFailWith(HttpStatusCode.NotModified);
var updatedOrder = await Configuration.Current.Repository<Order>().GetLatest(order.Id);
updatedOrder.Items.Single().Quantity.Should().Be(5);
}
public void A_series_of_calls_to_NextETag_produces_the_same_sequence_given_the_same_initial_etag()
{
var target = Any.Guid().ToString();
var command = new AddItem
{
ETag = Any.Word()
};
var sequence1 = new List<string>();
var sequence2 = new List<string>();
using (var ctx = CommandContext.Establish(command))
{
Enumerable.Range(1, 10).ForEach(_ => sequence1.Add(ctx.NextETag(target)));
}
using (var ctx = CommandContext.Establish(command))
{
Enumerable.Range(1, 10).ForEach(_ => sequence2.Add(ctx.NextETag(target)));
}
sequence1.Should().Equal(sequence2);
}
public void AddItem(AddItem rpc)
{
Item item = (Item)rpc.item;
itemStacks.Find((ItemStack s) => { return s.IsPushable(item); }).Push(item);
if (isMine)
GlobalSound.instance.PlayItemPick();
}
