Esempio n. 1
0
        public async Task Test_CanReadQueuedTaskResult()
        {
            Faker <QueuedTaskResult> qFaker =
                GetQueuedTaskResultFaker();

            QueuedTaskResult expectedTaskResult = qFaker
                                                  .Generate();

            await mOperations
            .AddQueuedTaskResultAsync(expectedTaskResult);

            using (NpgsqlConnection conn = await OpenDbConnectionAsync(ConnectionString))
                using (NpgsqlCommand cmd = new NpgsqlCommand($"SELECT * FROM {mMapping.ResultsQueueTableName} WHERE task_id = @t_id", conn))
                {
                    cmd.Parameters.AddWithValue("t_id",
                                                NpgsqlDbType.Uuid,
                                                expectedTaskResult.Id);

                    await cmd.PrepareAsync();

                    using (NpgsqlDataReader rdr = await cmd.ExecuteReaderAsync())
                    {
                        if (await rdr.ReadAsync())
                        {
                            QueuedTaskResult actualTaskResult = await rdr.ReadQueuedTaskResultAsync();

                            Assert.NotNull(actualTaskResult);
                            Assert.NotNull(actualTaskResult.Payload);
                            Assert.IsInstanceOf <SampleTaskPayload>(actualTaskResult.Payload);

                            Assert.AreEqual((( SampleTaskPayload )expectedTaskResult.Payload).Counter,
                                            (( SampleTaskPayload )actualTaskResult.Payload).Counter);

                            Assert.AreEqual(expectedTaskResult.Id, actualTaskResult.Id);
                            Assert.AreEqual(expectedTaskResult.Type, actualTaskResult.Type);
                            Assert.AreEqual(expectedTaskResult.Source, actualTaskResult.Source);
                            Assert.AreEqual(expectedTaskResult.Priority, actualTaskResult.Priority);
                            Assert.AreEqual(expectedTaskResult.ErrorCount, actualTaskResult.ErrorCount);
                            Assert.AreEqual(expectedTaskResult.LastErrorIsRecoverable, actualTaskResult.LastErrorIsRecoverable);
                            Assert.AreEqual(expectedTaskResult.LastError, actualTaskResult.LastError);

                            Assert.AreEqual(expectedTaskResult.Status, actualTaskResult.Status);

                            Assert.IsTrue(expectedTaskResult.PostedAtTs
                                          .EqualsAproximately(actualTaskResult.PostedAtTs));

                            Assert.IsTrue(expectedTaskResult.ProcessingFinalizedAtTs
                                          .EqualsAproximately(actualTaskResult.ProcessingFinalizedAtTs));

                            Assert.IsTrue(expectedTaskResult.FirstProcessingAttemptedAtTs
                                          .EqualsAproximately(actualTaskResult.FirstProcessingAttemptedAtTs));

                            Assert.IsTrue(expectedTaskResult.LastProcessingAttemptedAtTs
                                          .EqualsAproximately(actualTaskResult.LastProcessingAttemptedAtTs));
                        }
                    }

                    await conn.CloseAsync();
                }
        }