Captures the details of an item on an order.
Наследование: IUrchinActivity, IMeasurementActivity
        public void TransactionItemActivity_Constructor_With_Minimal_Parameters_Sets_Correct_Properties()
        {
            var activity = new TransactionItemActivity("code", "name", 1.23m, 1);

            Assert.AreEqual("code", activity.Code);
            Assert.AreEqual("name", activity.Name);
            Assert.AreEqual(1.23m, activity.Price);
            Assert.AreEqual(1, activity.Quantity);
            Assert.IsNull(activity.Variation);
        }
        public void ItemActivity_Constructor_With_All_Parameters_Sets_Correct_Properties()
        {
            var activity = new TransactionItemActivity("code", "name", 1.23m, 4, "variation");

            Assert.AreEqual("code", activity.Code);
            Assert.AreEqual("name", activity.Name);
            Assert.AreEqual(1.23m, activity.Price);
            Assert.AreEqual(4, activity.Quantity);
            Assert.AreEqual("variation", activity.Variation);
        }
Пример #3
0
        public void MeasurementTracker_Track_Carries_Forward_Last_Transaction()
        {
            var actual = new List<Uri>();
            var tracker = new MeasurementTracker(MeasurementTestHelpers.Configuration, MeasurementTestHelpers.CreateSessionManager(), MeasurementTestHelpers.CreateEnvironment(), actual.Add);

            var transaction = new TransactionActivity { OrderId = "123", Currency = "GBP" };
            tracker.Track(transaction);

            var transactionItem = new TransactionItemActivity("ABC", "Unit Test", 1.23m, 4);
            tracker.Track(transactionItem);

            Assert.AreEqual(transaction, transactionItem.Transaction);
            StringAssert.Contains(actual.Last().OriginalString, "ti=123");
        }
        internal static IEnumerable<KeyValuePair<string, string>> GetParameters(TransactionItemActivity itemActivity)
        {
            yield return KeyValuePair.Create("utmt", "item");
            yield return KeyValuePair.Create("utmipc", itemActivity.Code);
            yield return KeyValuePair.Create("utmipn", itemActivity.Name);
            yield return KeyValuePair.Create("utmipr", itemActivity.Price.ToString("0.00", CultureInfo.InvariantCulture));

            if (itemActivity.Quantity != 0)
                yield return KeyValuePair.Create("utmiqt", itemActivity.Quantity.ToString(CultureInfo.InvariantCulture));

            if (!String.IsNullOrEmpty(itemActivity.Variation))
                yield return KeyValuePair.Create("utmiva", itemActivity.Variation);
        }
        public void MeasurementActivityTracker_GetParameter_For_TransactionItemActivity_Returns_Correct_Values()
        {
            var tracker = new MeasurementActivityTracker();
            var transaction = new TransactionActivity { OrderId = "567", Currency = "GBP" };
            tracker.GetActivityParameters(transaction);
            var activity = new TransactionItemActivity("code", "name", 1.23m, 4096, "variation");
            var parameters = tracker.GetParameters(activity).ToDictionary(k => k.Key, v => v.Value);

            Assert.AreEqual(8, parameters.Keys.Count);
            Assert.AreEqual("item", parameters["t"]);

            Assert.AreEqual("567", parameters["ti"]);
            Assert.AreEqual("GBP", parameters["cu"]);

            Assert.AreEqual("code", parameters["ic"]);
            Assert.AreEqual("name", parameters["in"]);
            Assert.AreEqual("1.23", parameters["ip"]);
            Assert.AreEqual("4096", parameters["iq"]);
            Assert.AreEqual("variation", parameters["iv"]);
        }
 /// <summary>
 /// Add an itemActivity to the transaction.
 /// </summary>
 /// <param name="itemActivity"></param>
 public void AddItem(TransactionItemActivity itemActivity)
 {
     // We use a dictionary to simulate the correct behavior - each SKU can only have one entry and last wins.
     items[itemActivity.Code] = itemActivity;
 }
        /// <summary>
        /// Obtain the key/value pairs for a TransactionItemActivity.
        /// </summary>
        /// <param name="item">TransactionItemActivity to turn into key/value pairs.</param>
        /// <returns>Key/value pairs representing this TransactionItemActivity.</returns>
        internal static IEnumerable<KeyValuePair<string, string>> GetParameters(TransactionItemActivity item)
        {
            if (item.Transaction == null)
                yield break;

            yield return KeyValuePair.Create("t", "item");
            yield return KeyValuePair.Create("ti", item.Transaction.OrderId);

            foreach (var parameter in GetCommonParameters(item))
                yield return parameter;

            if (item.Price != Decimal.Zero)
                yield return KeyValuePair.Create("ip", item.Price.ToString("0.00", CultureInfo.InvariantCulture));

            if (item.Quantity != 0)
                yield return KeyValuePair.Create("iq", item.Quantity.ToString(CultureInfo.InvariantCulture));

            if (!String.IsNullOrWhiteSpace(item.Code))
                yield return KeyValuePair.Create("ic", item.Code);

            if (!String.IsNullOrWhiteSpace(item.Name))
                yield return KeyValuePair.Create("in", item.Name);

            if (!String.IsNullOrEmpty(item.Variation))
                yield return KeyValuePair.Create("iv", item.Variation);

            if (!String.IsNullOrWhiteSpace(item.Transaction.Currency))
                yield return KeyValuePair.Create("cu", item.Transaction.Currency);
        }
        public void UrchinActivityTracker_GetParameter_For_ItemActivity_Returns_Correct_Values()
        {
            var activity = new TransactionItemActivity("code", "name", 1.23m, 1);

            var parameters = UrchinActivityTracker.GetParameters(activity).ToDictionary(k => k.Key, v => v.Value);

            Assert.AreEqual("code", parameters["utmipc"]);
            Assert.AreEqual("name", parameters["utmipn"]);
            Assert.AreEqual("1.23", parameters["utmipr"]);
        }
        public void UrchinActivityTracker_GetParameter_For_ItemActivity_Returns_Correct_Utmt_Value()
        {
            var activity = new TransactionItemActivity("code", "name", 1.23m, 1);

            var results = UrchinActivityTracker.GetParameters(activity).ToDictionary(k => k.Key, v => v);

            CollectionAssert.Contains(results.Keys, "utmt");
            Assert.AreEqual("item", results["utmt"].Value);
        }
        public void UrchinActivityTracker_GetParameter_For_ItemActivity_Returns_Correct_Keys()
        {
            var activity = new TransactionItemActivity("code", "name", 1.23m, 4, "variation");

            var results = UrchinActivityTracker.GetParameters(activity).ToDictionary(k => k.Key, v => v);

            var expectedKeys = new[] { "utmt", "utmipc", "utmipn", "utmipr", "utmiqt", "utmiva" };
            CollectionAssert.AreEquivalent(expectedKeys, results.Keys);
        }
 /// <summary>
 /// Add an itemActivity to the transaction.
 /// </summary>
 /// <param name="itemActivity"></param>
 public void AddItem(TransactionItemActivity itemActivity)
 {
     // We use a dictionary to simulate the correct behavior - each SKU can only have one entry and last wins.
     items[itemActivity.Code] = itemActivity;
 }
        public void UrchinActivityParameterBuilder_GetParameter_For_ItemActivity_Returns_Correct_Optional_Values()
        {
            var activity = new TransactionItemActivity("code", "name", 1.23m, 4, "variation");

            var parameters = UrchinActivityParameterBuilder.GetParameters(activity).ToDictionary(k => k.Key, v => v.Value);

            Assert.AreEqual("variation", parameters["utmiva"]);
        }