public void ElementData_NullKey()
        {
            TestElementData data = new TestElementData(_pipeline.Object);
            string          key  = null;

            var result = data[key];
        }
        public void ElementData_NoData()
        {
            TestElementData data = new TestElementData(_pipeline.Object);
            string          key  = "key";

            var result = data[key];

            Assert.IsNull(result);
        }
        public void ElementData_PopulateFromDictionary_SingleValueWithProperty()
        {
            TestElementData             data    = new TestElementData(_pipeline.Object);
            Dictionary <string, object> newData = new Dictionary <string, object>();

            newData.Add("result", "value");
            data.PopulateFromDictionary(newData);

            Assert.AreEqual("value", data.Result);
        }
        public void ElementData_SimpleValueType()
        {
            TestElementData data = new TestElementData(_pipeline.Object);
            string          key  = "key";

            data[key] = 1;
            var result = data[key];

            Assert.AreEqual(1, result);
        }
        public void ElementData_String()
        {
            TestElementData data = new TestElementData(_pipeline.Object);
            string          key  = "key";

            data[key] = "value";
            var result = data[key];

            Assert.AreEqual("value", result);
        }
        public void ElementData_PopulateFromDictionary_Overwrite()
        {
            TestElementData             data    = new TestElementData(_pipeline.Object);
            Dictionary <string, object> newData = new Dictionary <string, object>();

            data["key1"] = "valueA";
            newData.Add("key1", "valueB");
            data.PopulateFromDictionary(newData);

            Assert.AreEqual("valueB", data["key1"]);
        }
        public void ElementData_AsIElementData()
        {
            TestElementData data = new TestElementData(_pipeline.Object);
            string          key  = "key";

            data[key] = "value";
            var dataAsInterface = data as IElementData;
            var result          = dataAsInterface[key];

            Assert.AreEqual("value", result);
        }
        public void ElementData_CaseInsensitiveKeySet()
        {
            TestElementData data = new TestElementData(_pipeline.Object);
            string          key  = "key";

            data[key]   = "value";
            data["Key"] = "otherValue";
            var result = data[key];

            Assert.AreEqual("otherValue", result);
        }
        public void ElementData_ComplexValueType()
        {
            TestElementData data = new TestElementData(_pipeline.Object);
            string          key  = "key";

            data[key] = new KeyValuePair <string, int>("test", 1);
            var result = (KeyValuePair <string, int>)data[key];

            Assert.AreEqual("test", result.Key);
            Assert.AreEqual(1, result.Value);
        }
        public void ElementData_PopulateFromDictionary_TwoValues()
        {
            TestElementData             data    = new TestElementData(_pipeline.Object);
            Dictionary <string, object> newData = new Dictionary <string, object>();

            newData.Add("key1", "value1");
            newData.Add("key2", "value2");
            data.PopulateFromDictionary(newData);

            Assert.AreEqual("value1", data["key1"]);
            Assert.AreEqual("value2", data["key2"]);
        }
        public void ElementData_AsDictionary()
        {
            TestElementData data = new TestElementData(_pipeline.Object);
            string          key  = "key";

            data[key] = "value";
            var dataAsDict = data.AsDictionary();

            var result = dataAsDict[key];

            Assert.AreEqual("value", result);
        }
        public void FlowData_UpdateDataAsDictionary()
        {
            _flowData.Process();
            string          key        = "key";
            TestElementData data       = new TestElementData(_pipeline.Object);
            var             dataAsDict = _flowData.ElementDataAsDictionary();

            dataAsDict.Add(key, data);
            var result = _flowData.Get(key);

            Assert.AreSame(data, result);
        }
        public void FlowData_GetDataAsDictionary()
        {
            string          key  = "key";
            TestElementData data = _flowData.GetOrAdd(
                key,
                (p) => new TestElementData(p));

            var result = _flowData.ElementDataAsDictionary();

            Assert.AreEqual(1, result.Count);
            Assert.AreSame(data, result[key]);
        }
        public void FlowData_AddDataTypedKey_GetDataElement()
        {
            _flowData.Process();
            var             element  = new TestElement();
            var             typedKey = new TypedKey <TestElementData>(element.ElementDataKey);
            TestElementData data     = _flowData.GetOrAdd(
                typedKey,
                (p) => new TestElementData(p));

            var result = _flowData.GetFromElement(element);

            Assert.AreSame(data, result);
        }
        public void FlowData_AddDataTypedKey_GetDataTypedKey()
        {
            _flowData.Process();
            string          key      = "key";
            var             typedKey = new TypedKey <TestElementData>(key);
            TestElementData data     = _flowData.GetOrAdd(
                typedKey,
                (p) => new TestElementData(p));

            var result = _flowData.Get(typedKey);

            Assert.AreSame(data, result);
        }
        public void ElementData_ComplexReferenceType()
        {
            TestElementData data = new TestElementData(_pipeline.Object);
            string          key  = "key";

            data[key] = new List <string>()
            {
                "a", "b"
            };
            var result = data[key] as List <string>;

            Assert.IsTrue(result.Contains("a"));
            Assert.IsTrue(result.Contains("b"));
        }
        public void ElementData_CaseSensitiveKey()
        {
            TestElementData data = new TestElementData(
                _pipeline.Object,
                new Dictionary <string, object>());
            string key = "key";

            data[key] = "value";
            var result      = data[key];
            var otherResult = data["Key"];

            Assert.AreEqual("value", result);
            Assert.IsNull(otherResult);
        }
        public void FlowData_GetDataAsEnumerable()
        {
            _flowData.Process();
            string          key  = "key";
            TestElementData data = _flowData.GetOrAdd(
                key,
                (p) => new TestElementData(p));

            var result = _flowData.ElementDataAsEnumerable();

            var count = 0;

            foreach (var elementData in result)
            {
                count++;
                Assert.AreSame(data, elementData);
            }
            Assert.AreEqual(1, count);
        }