public void Can_create_contentpublishingviewmodel_in_editmode_hardmode()
        {
            var repositoryFactory =
                new DSRepositoryFactory<IDynamicContentRepository, DSDynamicContentClient, DynamicContentEntityFactory>(
                    ServManager.GetUri(ServiceNameEnum.DynamicContent));

            var storeRepositoryFactory =
                new DSRepositoryFactory<IStoreRepository, DSDynamicContentClient, DynamicContentEntityFactory>(
                    ServManager.GetUri(ServiceNameEnum.DynamicContent));

            var countryRepositoryFactory =
                new DSRepositoryFactory<ICountryRepository, DSDynamicContentClient, DynamicContentEntityFactory>(
                    ServManager.GetUri(ServiceNameEnum.DynamicContent));
            var appConfigRepositoryFactory =
               new DSRepositoryFactory<IAppConfigRepository, DSDynamicContentClient, DynamicContentEntityFactory>(
                   ServManager.GetUri(ServiceNameEnum.DynamicContent));

            var searchCategoryVmFactory =
               new TestDynamicContentViewModelFactory<ISearchCategoryViewModel>(
                   ServManager.GetUri(ServiceNameEnum.DynamicContent));

            var navigationManager = new TestNavigationManager();

            DynamicContentPlace[] contentPlaces;
            DynamicContentItem[] contentItems;
            using (var repository = repositoryFactory.GetRepositoryInstance())
            {
                contentPlaces = TestContentPlacesBuilder.BuildContentPlaces().GetPlaces().ToArray();
                contentItems = TestContentItemsBuilder.BuildsContentItems().GetItems().ToArray();

                RepositoryHelper.AddItemToRepository(repository, contentItems.AsEnumerable());
                RepositoryHelper.AddItemToRepository(repository, contentPlaces.AsEnumerable());
            }

            //create fake innerItem
            var entityFactory = new DynamicContentEntityFactory();

            var item =
                TestContentPublishingBuilder.BuildDynamicContentPublishingGroup()
                    .WithContentItems(contentItems.Take(1).ToArray())
                    .WithContentPlaces(contentPlaces.Take(1).ToArray())
                    .GetContentPublishingGroup();

            using (var repository = repositoryFactory.GetRepositoryInstance())
            {
                RepositoryHelper.AddItemToRepository(repository, item);
            }

            var detailViewModel = new ContentPublishingItemViewModel(appConfigRepositoryFactory, countryRepositoryFactory, searchCategoryVmFactory, repositoryFactory, entityFactory, storeRepositoryFactory, navigationManager, item);
            Assert.NotNull(detailViewModel);
            detailViewModel.InitializeForOpen();

            detailViewModel.InnerItem.Name = "EditName";

            //edit 2 step
            detailViewModel.InnerItemContentPlaces.Add(contentPlaces[1]);
            detailViewModel.InnerItemContentPlaces.Remove(contentPlaces[1]);
            detailViewModel.InnerItemContentPlaces.Add(contentPlaces[1]);
            detailViewModel.InnerItemContentPlaces.Remove(contentPlaces[1]);
            detailViewModel.InnerItemContentPlaces.Add(contentPlaces[1]);

            //edit 3 step
            detailViewModel.InnerItemDynamicContent.Add(contentItems[2]);
            detailViewModel.InnerItemDynamicContent.Remove(contentItems[2]);
            detailViewModel.InnerItemDynamicContent.Add(contentItems[2]);
            detailViewModel.InnerItemDynamicContent.Remove(contentItems[2]);


            //edit 4 step
            var expressionViewModel = detailViewModel.ExpressionElementBlock.ExpressionViewModel;
            detailViewModel.ExpressionElementBlock.Children[0] =
                TestContentPublishingExpressionBuilder.BuildContentPublishingExpressionBuilder(
                    detailViewModel.ExpressionElementBlock.Children[0])
                    .AddCartTotalElement(expressionViewModel).AddConditionAddOrBlock(expressionViewModel).GetChild();

            Assert.True(detailViewModel.IsValid);
            detailViewModel.SaveWithoutUIChanges();


            //check the item from db
            using (var repository = repositoryFactory.GetRepositoryInstance())
            {
                var itemFromDb =
                    repository.PublishingGroups.Where(
                        pg =>
                            pg.DynamicContentPublishingGroupId ==
                            detailViewModel.InnerItem.DynamicContentPublishingGroupId)
                        .Expand(pg => pg.ContentItems).Expand(pg => pg.ContentPlaces).SingleOrDefault();

                Assert.NotNull(itemFromDb);
                Assert.True(itemFromDb.ContentItems.Count == 1);
                Assert.True(itemFromDb.ContentPlaces.Count == 2);
                Assert.True(itemFromDb.Name == "EditName");
                Assert.NotNull(itemFromDb.ConditionExpression);
                Assert.NotNull(itemFromDb.PredicateVisualTreeSerialized);
            }


        }
        public void Can_create_contentpublishingviewmodel_in_editmode_simpleacenarios()
        {
            var repositoryFactory =
                new DSRepositoryFactory<IDynamicContentRepository, DSDynamicContentClient, DynamicContentEntityFactory>(
                    ServManager.GetUri(ServiceNameEnum.DynamicContent));

            var storeRepositoryFactory =
               new DSRepositoryFactory<IStoreRepository, DSDynamicContentClient, DynamicContentEntityFactory>(
                   ServManager.GetUri(ServiceNameEnum.DynamicContent));

            var countryRepositoryFactory =
               new DSRepositoryFactory<ICountryRepository, DSDynamicContentClient, DynamicContentEntityFactory>(
                   ServManager.GetUri(ServiceNameEnum.DynamicContent));

            var appConfigRepositoryFactory =
               new DSRepositoryFactory<IAppConfigRepository, DSDynamicContentClient, DynamicContentEntityFactory>(
                   ServManager.GetUri(ServiceNameEnum.DynamicContent));

            var searchCategoryVmFactory =
               new TestDynamicContentViewModelFactory<ISearchCategoryViewModel>(
                   ServManager.GetUri(ServiceNameEnum.DynamicContent));

            var navigationManager = new TestNavigationManager();

            DynamicContentPlace[] contentPlaces;
            DynamicContentItem[] contentItems;
            using (var repository = repositoryFactory.GetRepositoryInstance())
            {
                contentPlaces = TestContentPlacesBuilder.BuildContentPlaces().GetPlaces().ToArray();
                contentItems = TestContentItemsBuilder.BuildsContentItems().GetItems().ToArray();

                RepositoryHelper.AddItemToRepository(repository, contentPlaces.AsEnumerable());
                RepositoryHelper.AddItemToRepository(repository, contentItems.AsEnumerable());
            }

            //create fake innerItem
            var entityFactory = new DynamicContentEntityFactory();

            var item =
                TestContentPublishingBuilder.BuildDynamicContentPublishingGroup()
                    .WithContentItems(contentItems)
                    .WithContentPlaces(contentPlaces)
                    .GetContentPublishingGroup();

            using (var repository = repositoryFactory.GetRepositoryInstance())
            {
                RepositoryHelper.AddItemToRepository(repository, item);
            }

            var detailViewModel = new ContentPublishingItemViewModel(appConfigRepositoryFactory, countryRepositoryFactory, searchCategoryVmFactory, repositoryFactory, entityFactory, storeRepositoryFactory, navigationManager, item);
            Assert.NotNull(detailViewModel);
            detailViewModel.InitializeForOpen();



            //edit properties in detail viewmodel
            detailViewModel.InnerItem.Name = string.Empty;
            detailViewModel.InnerItem.Description = "EditDescription";
            detailViewModel.InnerItem.Priority = 23;

            detailViewModel.InnerItemDynamicContent.Clear();
            detailViewModel.InnerItemDynamicContent.Add(contentItems[1]);

            detailViewModel.InnerItemContentPlaces.Clear();
            detailViewModel.InnerItemContentPlaces.Add(contentPlaces[1]);

            detailViewModel.InnerItem.Name = "EditName";
            Assert.True(detailViewModel.IsValid);


            detailViewModel.SaveWithoutUIChanges();

            using (var repository = repositoryFactory.GetRepositoryInstance())
            {
                var itemFromDb =
                    repository.PublishingGroups.Where(
                        pg =>
                            pg.DynamicContentPublishingGroupId ==
                            detailViewModel.InnerItem.DynamicContentPublishingGroupId)
                        .Expand(pg => pg.ContentItems).Expand(pg => pg.ContentPlaces).SingleOrDefault();

                Assert.NotNull(itemFromDb);
                Assert.True(itemFromDb.ContentItems[0].DynamicContentItemId == contentItems[1].DynamicContentItemId);
                Assert.True(itemFromDb.ContentPlaces[0].DynamicContentPlaceId == contentPlaces[1].DynamicContentPlaceId);
                Assert.True(itemFromDb.Name == "EditName");
            }
        }
コード例 #3
0
		public void Can_add_update_delete_item_property_values()
		{
			var catalogName = "Test catalog";
			var catalogBuilder = CatalogBuilder.BuildCatalog(catalogName).WithCategory("category").WithProducts(1);
			var catalog = catalogBuilder.GetCatalog() as Catalog;
			var item = catalogBuilder.GetItems()[0];

			var property1 = new Property { Name = "bool", PropertyValueType = PropertyValueType.Boolean.GetHashCode() };
			var property2 = new Property { Name = "datetime", PropertyValueType = PropertyValueType.DateTime.GetHashCode() };
			var property3 = new Property { Name = "Decimal", PropertyValueType = PropertyValueType.Decimal.GetHashCode() };
			var property4 = new Property { Name = "int", PropertyValueType = PropertyValueType.Integer.GetHashCode() };
			var property5 = new Property { Name = "longstr", PropertyValueType = PropertyValueType.LongString.GetHashCode() };
			var property6 = new Property { Name = "shorttext", PropertyValueType = PropertyValueType.ShortString.GetHashCode() };

			var propertySet = catalog.PropertySets[0];
			propertySet.PropertySetProperties.Add(new PropertySetProperty { Property = property1 });
			propertySet.PropertySetProperties.Add(new PropertySetProperty { Property = property2 });
			propertySet.PropertySetProperties.Add(new PropertySetProperty { Property = property3 });
			propertySet.PropertySetProperties.Add(new PropertySetProperty { Property = property4 });
			propertySet.PropertySetProperties.Add(new PropertySetProperty { Property = property5 });
			propertySet.PropertySetProperties.Add(new PropertySetProperty { Property = property6 });
			propertySet.PropertySetProperties.ToList().ForEach(x =>
			{
				x.Property.IsRequired = true;
				x.Property.CatalogId = catalogName;
			});

			var repositoryFactory = new DSRepositoryFactory<ICatalogRepository, DSCatalogClient, CatalogEntityFactory>(ServManager.GetUri(ServiceNameEnum.Catalog));
			using (var repository = repositoryFactory.GetRepositoryInstance())
			{
				repository.Add(catalog);
				repository.Add(item);
				repository.UnitOfWork.Commit();
			}

			IRepositoryFactory<IPricelistRepository> pricelistRepositoryFactory = new DSRepositoryFactory<IPricelistRepository, DSCatalogClient, CatalogEntityFactory>(ServManager.GetUri(ServiceNameEnum.Catalog));
			IViewModelsFactory<IPropertyValueBaseViewModel> propertyValueVmFactory = new TestCatalogViewModelFactory<IPropertyValueBaseViewModel>(ServManager.GetUri(ServiceNameEnum.Catalog), ServManager.GetUri(ServiceNameEnum.AppConfig));
			IViewModelsFactory<IPriceViewModel> priceVmFactory = new TestCatalogViewModelFactory<IPriceViewModel>(ServManager.GetUri(ServiceNameEnum.Catalog), ServManager.GetUri(ServiceNameEnum.AppConfig));
			IViewModelsFactory<IItemAssetViewModel> assetVmFactory = new TestCatalogViewModelFactory<IItemAssetViewModel>(ServManager.GetUri(ServiceNameEnum.Catalog), ServManager.GetUri(ServiceNameEnum.AppConfig));
			IViewModelsFactory<IAssociationGroupEditViewModel> associationGroupEditVmFactory = new TestCatalogViewModelFactory<IAssociationGroupEditViewModel>(ServManager.GetUri(ServiceNameEnum.Catalog), ServManager.GetUri(ServiceNameEnum.AppConfig));
			IViewModelsFactory<IAssociationGroupViewModel> associationGroupVmFactory = new TestCatalogViewModelFactory<IAssociationGroupViewModel>(ServManager.GetUri(ServiceNameEnum.Catalog), ServManager.GetUri(ServiceNameEnum.AppConfig));
			IViewModelsFactory<IItemRelationViewModel> itemRelationVmFactory = new TestCatalogViewModelFactory<IItemRelationViewModel>(ServManager.GetUri(ServiceNameEnum.Catalog), ServManager.GetUri(ServiceNameEnum.AppConfig));
			IViewModelsFactory<IEditorialReviewViewModel> reviewVmFactory = new TestCatalogViewModelFactory<IEditorialReviewViewModel>(ServManager.GetUri(ServiceNameEnum.Catalog), ServManager.GetUri(ServiceNameEnum.AppConfig));
			IViewModelsFactory<ICategoryItemRelationViewModel> categoryVmFactory = new TestCatalogViewModelFactory<ICategoryItemRelationViewModel>(ServManager.GetUri(ServiceNameEnum.Catalog), ServManager.GetUri(ServiceNameEnum.AppConfig));
			ICatalogEntityFactory entityFactory = new CatalogEntityFactory();
			IAuthenticationContext authContext = new TestAuthenticationContext();
			INavigationManager navManager = new TestNavigationManager();

			var itemViewModel = new ItemViewModel(null, null, repositoryFactory, pricelistRepositoryFactory, propertyValueVmFactory, priceVmFactory, assetVmFactory, associationGroupEditVmFactory, associationGroupVmFactory, itemRelationVmFactory, reviewVmFactory, categoryVmFactory, entityFactory, item, authContext, navManager);
			itemViewModel.InitializeForOpen();

			// property change should set IsModified to true
			itemViewModel.InnerItem.EndDate = DateTime.UtcNow;
			Assert.True(itemViewModel.IsModified);

			Assert.False(itemViewModel.PropertyValueEditCommand.CanExecute(null));
			Assert.True(itemViewModel.PropertyValueEditCommand.CanExecute(itemViewModel.PropertiesAndValues[0]));

			itemViewModel.CommonConfirmRequest.Raised += EditValueSetConfirmation;

			foreach (var propItem in itemViewModel.PropertiesAndValues)
			{
				itemViewModel.PropertyValueEditCommand.Execute(propItem);
			}

			itemViewModel.SaveChangesCommand.Execute(null);
			Thread.Sleep(1000);// waiting for SaveChangesCommand to finish in background thread

			using (var repository = repositoryFactory.GetRepositoryInstance())
			{
				var itemFromDb = repository.Items.Expand(x => x.ItemPropertyValues).Single();

				Assert.True(itemFromDb.ItemPropertyValues.Count > 0);
				Assert.Equal(itemViewModel.PropertiesAndValues.Count, itemFromDb.ItemPropertyValues.Count);
			}

			// test if values are saved when updated in UI
			DecimalValue = 123123m;
			var valueToEdit =
				itemViewModel.PropertiesAndValues.First(x => x.Property.PropertyValueType == PropertyValueType.Decimal.GetHashCode());
			itemViewModel.PropertyValueEditCommand.Execute(valueToEdit);

			LongTextValue = "other long text";
			valueToEdit = itemViewModel.PropertiesAndValues.First(x => x.Property.PropertyValueType == PropertyValueType.LongString.GetHashCode());
			itemViewModel.PropertyValueEditCommand.Execute(valueToEdit);

			itemViewModel.SaveChangesCommand.Execute(null);
			Thread.Sleep(1000);// waiting for SaveChangesCommand to finish in background thread

			using (var repository = repositoryFactory.GetRepositoryInstance())
			{
				var itemFromDb = repository.Items.Expand(x => x.ItemPropertyValues).Single();

				Assert.Equal(DecimalValue, itemFromDb.ItemPropertyValues.First(x => x.ValueType == PropertyValueType.Decimal.GetHashCode()).DecimalValue);
				Assert.Equal(LongTextValue, itemFromDb.ItemPropertyValues.First(x => x.ValueType == PropertyValueType.LongString.GetHashCode()).LongTextValue);
			}

			// check if item can be saved without required property value
			var valueToDelete =
				itemViewModel.PropertiesAndValues.First(x => x.Property.PropertyValueType == PropertyValueType.Decimal.GetHashCode());
			itemViewModel.PropertyValueDeleteCommand.Execute(valueToDelete);

			itemViewModel.SaveChangesCommand.CanExecute(null);
			Thread.Sleep(1000);// waiting for SaveChangesCommand to finish in background thread

			//Assert True as the last Save command execution failed as the validation failed
			Assert.True(itemViewModel.IsModified);
		}
コード例 #4
0
		public void Can_delete_pricelist()
		{
			#region Init parameters for PriceListHomeViewModel

			var priceListRepositoryFactory =
				new DSRepositoryFactory<IPricelistRepository, DSCatalogClient, CatalogEntityFactory>(
					ServManager.GetUri(ServiceNameEnum.Catalog));
			IAuthenticationContext authenticationContext = new TestAuthenticationContext();
			var navigationManager = new TestNavigationManager();

			// create ViewModelsFactory ( it should be resolve all view models for the test)
			var itemVmFactory = new TestCatalogViewModelFactory<IPriceListViewModel>(ServManager.GetUri(ServiceNameEnum.Catalog),
																		   ServManager.GetUri(ServiceNameEnum.AppConfig));

			var wizardVmFactory = new TestCatalogViewModelFactory<ICreatePriceListViewModel>(ServManager.GetUri(ServiceNameEnum.Catalog),
																		   ServManager.GetUri(ServiceNameEnum.AppConfig));

			// create Item using EntityFactory
			var entityFactory = new CatalogEntityFactory();

			#endregion

			#region Add price list to DB

			using (var repository = priceListRepositoryFactory.GetRepositoryInstance())
			{
				var pricelist = entityFactory.CreateEntity<Pricelist>();
				pricelist.Name = "Test price (Can_delete_pricelist)";
				pricelist.Currency = "USD";

				repository.Add(pricelist);
				repository.UnitOfWork.Commit();
			}

			#endregion

			#region VM test

			var priceListHomeViewModel = new PriceListHomeViewModel(entityFactory, itemVmFactory, wizardVmFactory,
																	priceListRepositoryFactory, authenticationContext,
																	navigationManager, null);
			priceListHomeViewModel.InitializeForOpen();

			Thread.Sleep(3000); // waiting for InitializeForOpen to finish in background thread

			priceListHomeViewModel.CommonConfirmRequest.Raised += DeletePriceListConfirmation;
			priceListHomeViewModel.ListItemsSource.MoveCurrentToFirst();
			var item = priceListHomeViewModel.ListItemsSource.CurrentItem as VirtualListItem<IPriceListViewModel>;
			var itemsToDelete = new List<VirtualListItem<IPriceListViewModel>>() { item };
			priceListHomeViewModel.ItemDeleteCommand.Execute(itemsToDelete);

			Thread.Sleep(1000);// waiting for ItemDeleteCommand to finish in background thread

			#endregion

			#region Check

			using (var repository = priceListRepositoryFactory.GetRepositoryInstance())
			{
				var checkItem = repository.Pricelists.Where(x => x.Name == "Test price (Can_delete_pricelist)").SingleOrDefault();
				Assert.Null(checkItem);
			}

			#endregion
		}
コード例 #5
0
		public void create_storeviewmodel_in_detailmode_and_edit()
		{
			var overviewVmFactory = new TestFulfillmentViewModelFactory<IStoreOverviewStepViewModel>(
				ServManager.GetUri(ServiceNameEnum.Store), ServManager.GetUri(ServiceNameEnum.Catalog),
				ServManager.GetUri(ServiceNameEnum.Order), ServManager.GetUri(ServiceNameEnum.AppConfig));

			var navigationVmFactory = new TestFulfillmentViewModelFactory<IStoreNavigationStepViewModel>(
				ServManager.GetUri(ServiceNameEnum.Store), ServManager.GetUri(ServiceNameEnum.Catalog),
				ServManager.GetUri(ServiceNameEnum.Order), ServManager.GetUri(ServiceNameEnum.AppConfig));

			var localizationVmFactory = new TestFulfillmentViewModelFactory<IStoreLocalizationStepViewModel>(
				ServManager.GetUri(ServiceNameEnum.Store), ServManager.GetUri(ServiceNameEnum.Catalog),
				ServManager.GetUri(ServiceNameEnum.Order), ServManager.GetUri(ServiceNameEnum.AppConfig));

			var taxesVmFactory = new TestFulfillmentViewModelFactory<IStoreTaxesStepViewModel>(
				ServManager.GetUri(ServiceNameEnum.Store), ServManager.GetUri(ServiceNameEnum.Catalog),
				ServManager.GetUri(ServiceNameEnum.Order), ServManager.GetUri(ServiceNameEnum.AppConfig));

			var paymentsVmFactory = new TestFulfillmentViewModelFactory<IStorePaymentsStepViewModel>(
				ServManager.GetUri(ServiceNameEnum.Store), ServManager.GetUri(ServiceNameEnum.Catalog),
				ServManager.GetUri(ServiceNameEnum.Order), ServManager.GetUri(ServiceNameEnum.AppConfig));

			var linkedStoresVmFactory = new TestFulfillmentViewModelFactory<IStoreLinkedStoresStepViewModel>(
				ServManager.GetUri(ServiceNameEnum.Store), ServManager.GetUri(ServiceNameEnum.Catalog),
				ServManager.GetUri(ServiceNameEnum.Order), ServManager.GetUri(ServiceNameEnum.AppConfig));

			var settingVmFactory = new TestFulfillmentViewModelFactory<IStoreSettingStepViewModel>(
				ServManager.GetUri(ServiceNameEnum.Store), ServManager.GetUri(ServiceNameEnum.Catalog),
				ServManager.GetUri(ServiceNameEnum.Order), ServManager.GetUri(ServiceNameEnum.AppConfig));

			var entityFactory = new StoreEntityFactory();
			var item = entityFactory.CreateEntity<Store>();

			var repositoryFactory =
				new DSRepositoryFactory<IStoreRepository, DSStoreClient, StoreEntityFactory>(
					ServManager.GetUri(ServiceNameEnum.Store));

			var navigationManager = new TestNavigationManager();



			//fill the properties of InnerItem;
			item.Name = "testName";
			item.Catalog = "testcatalog";
			item.Languages.Add(new StoreLanguage() { LanguageCode = "ru-ru", StoreId = item.StoreId });
			item.DefaultLanguage = "ru-ru";
			item.Currencies.Add(new StoreCurrency() { CurrencyCode = "RUR", StoreId = item.StoreId });
			item.DefaultCurrency = "RUR";

			using (var repository = repositoryFactory.GetRepositoryInstance())
			{
				repository.Add(item);
				repository.UnitOfWork.Commit();
			}


			var detailStoreViewModel = new StoreViewModel(repositoryFactory, entityFactory, overviewVmFactory, localizationVmFactory, taxesVmFactory, paymentsVmFactory, navigationVmFactory, settingVmFactory, linkedStoresVmFactory, null, null,
				navigationManager, item);
			Assert.NotNull(detailStoreViewModel);
			detailStoreViewModel.InitializeForOpen();


			//edit various properties
			detailStoreViewModel.InnerItem.Name = "EditingName";
			detailStoreViewModel.InnerItem.Catalog = "EditedCatalog";


			detailStoreViewModel.InnerItem.Languages.Add(new StoreLanguage()
			{
				LanguageCode = "de-de",
				StoreId = detailStoreViewModel.InnerItem.StoreId
			});
			detailStoreViewModel.InnerItem.DefaultLanguage = "de-de";

			detailStoreViewModel.InnerItem.Currencies.Add(new StoreCurrency()
			{
				CurrencyCode = "USD",
				StoreId = detailStoreViewModel.InnerItem.StoreId
			});


			detailStoreViewModel.TaxesStepViewModel.AvailableTaxCodes[0].IsChecked = true;
			detailStoreViewModel.TaxesStepViewModel.AvailableTaxCodes[1].IsChecked = true;
			detailStoreViewModel.TaxesStepViewModel.AvailableTaxJurisdictions[0].IsChecked = true;

			detailStoreViewModel.PaymentsStepViewModel.AvailableStoreCardTypes[0].IsChecked = true;

			(detailStoreViewModel.NavigationStepViewModel as StoreNavigationStepViewModel).SettingFilteredNavigation
				.LongTextValue = "NewNavigationText";

			detailStoreViewModel.SaveWithoutUIChanges();


			Store storeFromDb = null;
			using (var repository = repositoryFactory.GetRepositoryInstance())
			{
				storeFromDb =
					repository.Stores.Where(s => s.StoreId == detailStoreViewModel.InnerItem.StoreId).SingleOrDefault();

				Assert.NotNull(storeFromDb);
				Assert.True(storeFromDb.Name == "EditingName");
			}


			//edit various properties

			var detailStoreViewModel2 = new StoreViewModel(repositoryFactory, entityFactory, overviewVmFactory, localizationVmFactory, taxesVmFactory, paymentsVmFactory, navigationVmFactory, settingVmFactory, linkedStoresVmFactory, null, null,
			   navigationManager, item);
			Assert.NotNull(detailStoreViewModel2);
			detailStoreViewModel2.InitializeForOpen();

			detailStoreViewModel.InnerItem.Name = "2 edit";
			detailStoreViewModel.TaxesStepViewModel.AvailableTaxCodes[0].IsChecked = false;
			detailStoreViewModel.TaxesStepViewModel.AvailableTaxCodes[1].IsChecked = false;

			detailStoreViewModel.InnerItem.Settings.Add(new StoreSetting()
			{
				Name = "testSettings",
				ValueType = "0",
				ShortTextValue = "ShortTextValue",
				StoreId = detailStoreViewModel.InnerItem.StoreId
			});


			detailStoreViewModel.SaveWithoutUIChanges();


			using (var repository = repositoryFactory.GetRepositoryInstance())
			{
				var itemFromDb =
					repository.Stores.Where(s => s.StoreId == detailStoreViewModel.InnerItem.StoreId).Expand(s => s.Settings).SingleOrDefault();

				Assert.NotNull(itemFromDb);
				Assert.True(itemFromDb.Name == "2 edit");


				var setting = itemFromDb.Settings.SingleOrDefault(ss => ss.Name == "testSettings");
				Assert.NotNull(setting);

			}

		}