public void TestMethodSimpleImplicitCast() { Simple s = new Simple(); ReflectionUtil.CallMethod(s, "SetInt", 3.4f); Assert.AreEqual(3, s._a); }
/// <summary> /// 根据服务 id 和参数,调用服务,返回服务运行的结果 /// </summary> /// <param name="serviceId"></param> /// <param name="serviceParamValues">服务的参数</param> /// <param name="defaultValues">默认参数</param> /// <returns></returns> public static IList GetData(long serviceId, Dictionary <string, string> serviceParamValues, Dictionary <string, string> defaultValues) { ArrayList argList = new ArrayList(); Service service = Get(serviceId); IList parms = service.GetParams(); for (int i = 0; i < parms.Count; i++) { String pkey = "param" + i; String val = serviceParamValues.ContainsKey(pkey) ? serviceParamValues[pkey] : null; Object argValue = ((ParamControl)parms[i]).ChangeType(val); argList.Add(argValue); } foreach (KeyValuePair <String, String> pair in defaultValues) { Object argValue = getValue(service, pair); argList.Add(argValue); } object[] args = argList.ToArray(); Object objService = ObjectContext.GetByType(service.Type); return(ReflectionUtil.CallMethod(objService, service.Method, args) as IList); }
// In this method we re-retrieve the item form the repository and populate the // Sitecore item fields we care about from this item. By breaking this out from // GetItemDefinition, we're able to keeps things flexible in terms of later updates. public override FieldList GetItemFields(ItemDefinition itemDefinition, VersionUri versionUri, CallContext context) { if (this.canProcessItem(itemDefinition.ID)) { Trace.WriteLine(String.Format("GetItemFields({0}, {1}, {2})", itemDefinition, versionUri, context), "ProductDataProvider"); var fields = new FieldList(); var template = TemplateManager.GetTemplate(this.productTemplateId, this.ContentDatabase); if (template != null) { var originalId = this.getExternalId(itemDefinition.ID); if (originalId != Guid.Empty) { if (context.DataManager.DataSource.ItemExists(itemDefinition.ID)) { ReflectionUtil.CallMethod(typeof(ItemCache), "RemoveItem", true, true, new Object[] { itemDefinition.ID }); } var product = this.productRepository.Find(originalId); if (product != null) { foreach (var dataField in template.GetFields().Where(ItemUtil.IsDataField)) { fields.Add(dataField.ID, this.getFieldValue(dataField, product)); } } } } return(fields); } return(base.GetItemFields(itemDefinition, versionUri, context)); }
public void ShouldThrowExceptionIfNoFieldFoundInOriginalItem(SaveItemCommand sut, ID itemId, ID templateId, ID fieldId) { // arrange var originalItem = new DbItem("original item", itemId) { new DbField("Title") }; sut.DataStorage.GetFakeItem(itemId).Returns(originalItem); sut.DataStorage.GetFakeTemplate(null).ReturnsForAnyArgs(new DbTemplate("Sample", templateId)); var fields = new FieldList { { fieldId, "updated title" } }; var updatedItem = ItemHelper.CreateInstance(sut.Database, "updated item", itemId, ID.NewID, ID.Null, fields); sut.Initialize(updatedItem); // act Action action = () => ReflectionUtil.CallMethod(sut, "DoExecute"); // assert action .ShouldThrow <TargetInvocationException>() .WithInnerException <InvalidOperationException>() .WithInnerMessage("Item field not found. Item: 'updated item', '{0}'; field: '{1}'.".FormatWith(itemId, fieldId)); }
public void ShouldMoveItemToNewDestination(MoveItemCommand sut, Item item, Item destination, ID parentId, DataStorageSwitcher switcher) { // arrange var fakeItem = new DbItem("item", item.ID) { ParentID = parentId }; var fakeParent = new DbItem("parent", parentId) { Children = { fakeItem } }; var fakeDestination = new DbItem("destination", destination.ID) { FullPath = "/new destination path" }; sut.DataStorage.GetFakeItem(item.ID).Returns(fakeItem); sut.DataStorage.GetFakeItem(parentId).Returns(fakeParent); sut.DataStorage.GetFakeItem(destination.ID).Returns(fakeDestination); sut.Initialize(item, destination); // act var result = (bool)ReflectionUtil.CallMethod(sut, "DoExecute"); // assert result.Should().BeTrue(); fakeItem.ParentID.Should().Be(destination.ID); fakeItem.FullPath.Should().Be("/new destination path/item"); fakeParent.Children.Should().NotContain(fakeItem); fakeDestination.Children.Should().Contain(fakeItem); }
public void ShouldAddMissingFieldToItemIfFieldExistsInTemplate(SaveItemCommand sut, ID itemId, ID templateId, ID fieldId) { // arrange var template = new DbTemplate("Sample", templateId) { fieldId }; var originalItem = new DbItem("original item", itemId, templateId); sut.DataStorage.GetFakeItem(itemId).Returns(originalItem); sut.DataStorage.GetFakeTemplate(templateId).Returns(template); var fields = new FieldList { { fieldId, "updated title" } }; var updatedItem = ItemHelper.CreateInstance(sut.Database, "updated item", itemId, ID.NewID, ID.Null, fields); sut.Initialize(updatedItem); // act ReflectionUtil.CallMethod(sut, "DoExecute"); // assert originalItem.Name.Should().Be("updated item"); originalItem.Fields[fieldId].Value.Should().Be("updated title"); }
public void ShouldUpdateExistingItemInDataStorage(SaveItemCommand sut, ID itemId, ID templateId, ID fieldId) { // arrange var originalItem = new DbItem("original item", itemId) { new DbField("Title", fieldId) { Value = "original title" } }; sut.DataStorage.GetFakeItem(itemId).Returns(originalItem); sut.DataStorage.GetFakeTemplate(null).ReturnsForAnyArgs(new DbTemplate("Sample", templateId)); var fields = new FieldList { { fieldId, "updated title" } }; var updatedItem = ItemHelper.CreateInstance(sut.Database, "updated item", itemId, ID.NewID, ID.Null, fields); sut.Initialize(updatedItem); // act ReflectionUtil.CallMethod(sut, "DoExecute"); // assert originalItem.Name.Should().Be("updated item"); originalItem.Fields[fieldId].Value.Should().Be("updated title"); }
public void ShouldResolvePath(string path, ResolvePathCommand sut, DbItem item) { item.FullPath = "/sitecore/content/home"; sut.DataStorage.GetFakeItems().Returns(new[] { item }); sut.Initialize(path); ReflectionUtil.CallMethod(sut, "DoExecute").Should().Be(item.ID); }
public void ShouldReturnNullIfNoBlobStreamExistsInDataStorage(GetBlobStreamCommand sut, Guid blobId) { // arrange sut.Initialize(blobId); // act & assert ReflectionUtil.CallMethod(sut, "DoExecute").Should().BeNull(); }
public void DoExecuteThrowsNotSupportedException(Type command, DataStorage dataStorage) { var sut = ReflectionUtil.CreateObject(command, new object[] { dataStorage }); Action action = () => ReflectionUtil.CallMethod(sut, "CreateInstance"); action.ShouldThrow <TargetInvocationException>().WithInnerException <NotSupportedException>(); }
public void DoExecuteThrowsNotSupportedException(Type prototype) { var sut = Activator.CreateInstance(prototype, Database.GetDatabase("master")); Action action = () => ReflectionUtil.CallMethod(sut, "DoExecute"); action.ShouldThrow <TargetInvocationException>().WithInnerException <NotSupportedException>(); }
protected virtual void RemoveItemFromCaches(IItemMetadata metadata, string databaseName) { try { if (databaseName != Database.Name) { return; } // this is a bit heavy handed, sure. // but the caches get interdependent stuff - like caching child IDs // that make it difficult to cleanly remove a single item ID from all cases in the cache // either way, this should be a relatively rare occurrence (from runtime changes on disk) // and we're preserving prefetch, etc. Seems pretty zippy overall. CacheManager.ClearAllCaches(); if (metadata == null) { return; } if (metadata.TemplateId == TemplateIDs.Template.Guid || metadata.TemplateId == TemplateIDs.TemplateField.Guid || (metadata.Path != null && metadata.Path.EndsWith("__Standard Values", StringComparison.OrdinalIgnoreCase))) { Database.Engines.TemplateEngine.Reset(); } if (_syncConfiguration != null && (_syncConfiguration.UpdateLinkDatabase || _syncConfiguration.UpdateSearchIndex)) { var item = GetSourceItemFromId(new ID(metadata.Id), true); if (item == null) { return; } if (_syncConfiguration.UpdateLinkDatabase) { Globals.LinkDatabase.UpdateReferences(item); } if (_syncConfiguration.UpdateSearchIndex) { foreach (var index in ContentSearchManager.Indexes) { ReflectionUtil.CallMethod(typeof(IndexCustodian), "UpdateItem", true, true, true, new object[] { index, new SitecoreItemUniqueId(item.Uri) }); //IndexCustodian.UpdateItem(index, new SitecoreItemUniqueId(item.Uri)); } } } } catch (Exception ex) { // we catch this because this method runs on a background thread. If an unhandled exception occurs there, the app pool terminates and that's Naughty(tm). Log.Error($"[Unicorn] Exception occurred while processing a background item cache removal on {metadata?.Path ?? "unknown item"}", ex, this); } }
public void ShouldCreateInstance( CopyItemCommandPrototype sut, DataStorage dataStorage) { using (new DataStorageSwitcher(dataStorage)) { ReflectionUtil.CallMethod(sut, "CreateInstance").Should().BeOfType <CopyItemCommand>(); } }
public void ShouldGetBlobStreamFromDataStorage(GetBlobStreamCommand sut, Guid blobId, [Modest] MemoryStream stream) { // arrange sut.DataStorage.GetBlobStream(blobId).Returns(stream); sut.Initialize(blobId); // act & assert ReflectionUtil.CallMethod(sut, "DoExecute").Should().BeSameAs(stream); }
public void TestMethodSimple() { Simple s = new Simple(); s._a = 44; Assert.AreEqual(44, ReflectionUtil.CallMethod(s, "GetInt")); ReflectionUtil.CallMethod(s, "SetInt", 55); Assert.AreEqual(55, s._a); }
public void ShouldReturnTrueIfBlobStreamExistsInDataStorage(BlobStreamExistsCommand sut, Guid blobId, [Modest] MemoryStream stream) { // arrange sut.DataStorage.GetBlobStream(blobId).Returns(stream); sut.Initialize(blobId); // act & assert ReflectionUtil.CallMethod(sut, "DoExecute").Should().Be(true); }
private void ApplyCallbackUrlFix() { HttpContext current = HttpContext.Current; string url = current.Response.ApplyAppPathModifier(current.Request.RawUrl); string str2 = System.Convert.ToString(ReflectionUtil.CallMethod(this._grid, "GetSaneId", true, true)); var str3 = new UrlString(url); str3.Add("Cart_" + str2 + "_Callback", "yes"); this._grid.CallbackPrefix = str3.ToString(); }
public void ShouldReturnFalseIfNoItemFound(DeleteItemCommand sut, Item item, ID parentId) { // arrange sut.Initialize(item, parentId); // act var result = (bool)ReflectionUtil.CallMethod(sut, "DoExecute"); // assert result.Should().BeFalse(); }
public void ShouldReturnEmptyListIfNoItemFound(GetChildrenCommand sut, Item item) { // arrange sut.Initialize(item); // act var children = (ItemList)ReflectionUtil.CallMethod(sut, "DoExecute"); // assert children.Should().BeEmpty(); }
public void TestMethodGenericSimple2() { GenericOne <int> gi = new GenericOne <int> (); Assert.AreEqual(3, ReflectionUtil.CallMethod(gi, "GetInt", System.Reflection.BindingFlags.Public)); Assert.AreEqual(4, ReflectionUtil.CallMethod(gi, "GetT", 4)); Assert.AreEqual(4.3f, ReflectionUtil.CallMethod(gi, "GetS", new System.Type[] { typeof(float) }, 4.3f)); Assert.AreEqual("hoge", ReflectionUtil.CallMethod(gi, "Get2", System.Reflection.BindingFlags.Public, new System.Type[] { typeof(string) }, "hoge", 5)); Assert.AreEqual(5, gi._pa); }
public void ShouldSetBlobStreamInDataStorage(SetBlobStreamCommand sut, Guid blobId, [Modest] MemoryStream stream) { // arrange sut.Initialize(stream, blobId); // act ReflectionUtil.CallMethod(sut, "DoExecute"); // assert sut.DataStorage.Received().SetBlobStream(blobId, stream); }
public void ShouldResolveFirstItemId(ResolvePathCommand sut, DbItem item1, DbItem item2) { const string path = "/sitecore/content/home"; item1.FullPath = path; item2.FullPath = path; sut.DataStorage.GetFakeItems().Returns(new[] { item1, item2 }); sut.Initialize(path); ReflectionUtil.CallMethod(sut, "DoExecute").Should().Be(item1.ID); }
public void ShouldGetEmptyVersionCollectionIfNoFakeItemFound(GetVersionsCommand sut, Item item, Language language, DbItem dbitem) { // arrange sut.Initialize(item, language); // act var versionCollection = (VersionCollection)ReflectionUtil.CallMethod(sut, "DoExecute"); // assert versionCollection.Should().BeEmpty(); }
public FakeDataProviderTest() { var database = Database.GetDatabase("master"); this.dataStorage = new DataStorage(database); this.dataStorage.FakeItems.Clear(); this.dataStorage.FakeTemplates.Clear(); this.dataProvider = new FakeDataProvider(this.dataStorage); ReflectionUtil.CallMethod(database, "AddDataProvider", new object[] { this.dataProvider }); }
public void ShouldGetItemFromDataStorage(GetItemCommand sut, Item item) { // arrange sut.DataStorage.GetSitecoreItem(item.ID, item.Language, item.Version).Returns(item); sut.Initialize(item.ID, item.Language, item.Version); // act var result = ReflectionUtil.CallMethod(sut, "DoExecute"); // assert result.Should().Be(item); }
public void ShouldIncreaseFakeItemVersionCount(AddVersionCommand sut, Item item, DbItem dbItem) { // arrange sut.DataStorage.GetFakeItem(item.ID).Returns(dbItem); sut.Initialize(item); // act ReflectionUtil.CallMethod(sut, "DoExecute"); // assert dbItem.GetVersionCount("en").Should().Be(1); }
public void ShouldReturnRootItem(GetRootItemCommand sut, Item rootItem) { // arrange sut.DataStorage.GetSitecoreItem(ItemIDs.RootID, rootItem.Language).Returns(rootItem); sut.Initialize(LanguageManager.DefaultLanguage, Version.Latest); // act var result = ReflectionUtil.CallMethod(sut, "DoExecute"); // assert result.Should().Be(rootItem); }
public void ShouldReturnCreatedItem(AddFromTemplateCommand sut, Item item, Item destination) { // arrange sut.DataStorage.GetSitecoreItem(item.ID).Returns(item); sut.Initialize(item.Name, item.TemplateID, destination, item.ID); // act var result = ReflectionUtil.CallMethod(sut, "DoExecute"); // assert result.Should().Be(item); }
/// <summary> /// Removes the sitecore item from the ItemCache /// </summary> /// <remarks> /// Two of the cache levels for Sitecore is ItemCache and DataCache. /// The data level caches the data parts of the item. /// The item level caches the completed item. /// /// So when we return new data parts, we need to push the item out of the item cache /// to make Sitecore hit the Data cache with the updated data, the next time the item /// is requested. /// </remarks> /// <param name="itemId">The item id to remove from the Item cache.</param> /// <param name="context">The context.</param> private void RemoveItemFromSitecoresItemCache(ID itemId, Database context) { if (context.DataManager.DataSource.ItemExists(itemId)) { // The method called using reflection is no longer private, but for backwards compatibility // We still call it the voodoo way. ReflectionUtil.CallMethod( typeof(ItemCache), CacheManager.GetItemCache(context.DataManager.Database), "RemoveItem", true, true, new object[] { itemId }); //_log.Log<DataProviderMasterDatabase>("Called remove item from cache using reflection."); } }
public void ShouldReturnNullIfNoParentFound(GetParentCommand sut, Item item) { // arrange sut.Initialize(item); // act var result = ReflectionUtil.CallMethod(sut, "DoExecute"); // assert result.Should().BeNull(); sut.DataStorage.DidNotReceiveWithAnyArgs().GetSitecoreItem(null, null); }