From 3291fa3630c456450f8c6a9b771f77c293d036cd Mon Sep 17 00:00:00 2001 From: Aidan Haran Date: Sat, 16 Sep 2017 19:59:32 +0100 Subject: Allow for custom handling of exceptions that are discarded --- activejob/test/cases/exceptions_test.rb | 7 +++++++ 1 file changed, 7 insertions(+) (limited to 'activejob/test/cases') diff --git a/activejob/test/cases/exceptions_test.rb b/activejob/test/cases/exceptions_test.rb index 7a3c372143..7b8f1dcca7 100644 --- a/activejob/test/cases/exceptions_test.rb +++ b/activejob/test/cases/exceptions_test.rb @@ -58,6 +58,13 @@ class ExceptionsTest < ActiveJob::TestCase end end + test "custom handling of discarded job" do + perform_enqueued_jobs do + RetryJob.perform_later "CustomDiscardableError", 2 + assert_equal "Dealt with a job that was discarded in a custom way", JobBuffer.last_value + end + end + test "custom handling of job that exceeds retry attempts" do perform_enqueued_jobs do RetryJob.perform_later "CustomCatchError", 6 -- cgit v1.2.3 From e360ac12315ed6b9eadca5bcc0d95dc766ba8523 Mon Sep 17 00:00:00 2001 From: Evgenii Pecherkin Date: Tue, 17 Oct 2017 16:05:05 +0400 Subject: Introduce serializers to ActiveJob --- activejob/test/cases/argument_serialization_test.rb | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) (limited to 'activejob/test/cases') diff --git a/activejob/test/cases/argument_serialization_test.rb b/activejob/test/cases/argument_serialization_test.rb index 7e7f854da0..20296038a0 100644 --- a/activejob/test/cases/argument_serialization_test.rb +++ b/activejob/test/cases/argument_serialization_test.rb @@ -4,6 +4,7 @@ require "helper" require "active_job/arguments" require "models/person" require "active_support/core_ext/hash/indifferent_access" +require "active_support/duration" require "jobs/kwargs_job" class ArgumentSerializationTest < ActiveSupport::TestCase @@ -12,7 +13,8 @@ class ArgumentSerializationTest < ActiveSupport::TestCase end [ nil, 1, 1.0, 1_000_000_000_000_000_000_000, - "a", true, false, BigDecimal(5), + "a", true, false, BigDecimal.new(5), + :a, self, 1.day, [ 1, "a" ], { "a" => 1 } ].each do |arg| @@ -21,7 +23,7 @@ class ArgumentSerializationTest < ActiveSupport::TestCase end end - [ :a, Object.new, self, Person.find("5").to_gid ].each do |arg| + [ Object.new, Person.find("5").to_gid ].each do |arg| test "does not serialize #{arg.class}" do assert_raises ActiveJob::SerializationError do ActiveJob::Arguments.serialize [ arg ] @@ -33,6 +35,10 @@ class ArgumentSerializationTest < ActiveSupport::TestCase end end + test "serializes Struct" do + assert_arguments_unchanged Struct.new("Rectangle", :width, :height).new(10, 15) + end + test "should convert records to Global IDs" do assert_arguments_roundtrip [@person] end -- cgit v1.2.3 From 3785a5729959a838bb13f2d298a59e12e1844f74 Mon Sep 17 00:00:00 2001 From: Evgenii Pecherkin Date: Mon, 23 Oct 2017 17:29:28 +0400 Subject: Remove non-default serializers --- .../test/cases/argument_serialization_test.rb | 8 +-- activejob/test/cases/serializers_test.rb | 64 ++++++++++++++++++++++ 2 files changed, 65 insertions(+), 7 deletions(-) create mode 100644 activejob/test/cases/serializers_test.rb (limited to 'activejob/test/cases') diff --git a/activejob/test/cases/argument_serialization_test.rb b/activejob/test/cases/argument_serialization_test.rb index 20296038a0..13e6fcb727 100644 --- a/activejob/test/cases/argument_serialization_test.rb +++ b/activejob/test/cases/argument_serialization_test.rb @@ -4,7 +4,6 @@ require "helper" require "active_job/arguments" require "models/person" require "active_support/core_ext/hash/indifferent_access" -require "active_support/duration" require "jobs/kwargs_job" class ArgumentSerializationTest < ActiveSupport::TestCase @@ -14,7 +13,6 @@ class ArgumentSerializationTest < ActiveSupport::TestCase [ nil, 1, 1.0, 1_000_000_000_000_000_000_000, "a", true, false, BigDecimal.new(5), - :a, self, 1.day, [ 1, "a" ], { "a" => 1 } ].each do |arg| @@ -23,7 +21,7 @@ class ArgumentSerializationTest < ActiveSupport::TestCase end end - [ Object.new, Person.find("5").to_gid ].each do |arg| + [ :a, Object.new, self, Person.find("5").to_gid ].each do |arg| test "does not serialize #{arg.class}" do assert_raises ActiveJob::SerializationError do ActiveJob::Arguments.serialize [ arg ] @@ -35,10 +33,6 @@ class ArgumentSerializationTest < ActiveSupport::TestCase end end - test "serializes Struct" do - assert_arguments_unchanged Struct.new("Rectangle", :width, :height).new(10, 15) - end - test "should convert records to Global IDs" do assert_arguments_roundtrip [@person] end diff --git a/activejob/test/cases/serializers_test.rb b/activejob/test/cases/serializers_test.rb new file mode 100644 index 0000000000..90d4155b3b --- /dev/null +++ b/activejob/test/cases/serializers_test.rb @@ -0,0 +1,64 @@ +# frozen_string_literal: true + +require "helper" +require "active_job/serializers" + +class SerializersTest < ActiveSupport::TestCase + class DummyValueObject + attr_accessor :value + + def initialize(value) + @value = value + end + end + + class DummySerializer < ActiveJob::Serializers::ObjectSerializer + class << self + def serialize(object) + { key => object.value } + end + + def deserialize(hash) + DummyValueObject.new(hash[key]) + end + + def key + "_dummy_serializer" + end + + private + + def klass + DummyValueObject + end + end + end + + setup do + @value_object = DummyValueObject.new 123 + ActiveJob::Base._additional_serializers = [] + end + + test "can't serialize unknown object" do + assert_raises ActiveJob::SerializationError do + ActiveJob::Serializers.serialize @value_object + end + end + + test "won't deserialize unknown hash" do + hash = { "_dummy_serializer" => 123, "_aj_symbol_keys" => [] } + assert ActiveJob::Serializers.deserialize(hash), hash.except("_aj_symbol_keys") + end + + test "adds new serializer" do + ActiveJob::Base.add_serializers DummySerializer + assert ActiveJob::Base.serializers.include?(DummySerializer) + end + + test "can't add serializer with the same key twice" do + ActiveJob::Base.add_serializers DummySerializer + assert_raises ArgumentError do + ActiveJob::Base.add_serializers DummySerializer + end + end +end -- cgit v1.2.3 From ec686a471e0a54194fc9ec72e639785606597704 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafael=20Mendon=C3=A7a=20Fran=C3=A7a?= Date: Fri, 9 Feb 2018 14:24:55 -0500 Subject: Simplify the implementation of custom serialziers Right now it is only possible to define serializers globally so we don't need to use a class attribute in the job class. --- activejob/test/cases/serializers_test.rb | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) (limited to 'activejob/test/cases') diff --git a/activejob/test/cases/serializers_test.rb b/activejob/test/cases/serializers_test.rb index 90d4155b3b..3b526c932b 100644 --- a/activejob/test/cases/serializers_test.rb +++ b/activejob/test/cases/serializers_test.rb @@ -36,7 +36,11 @@ class SerializersTest < ActiveSupport::TestCase setup do @value_object = DummyValueObject.new 123 - ActiveJob::Base._additional_serializers = [] + @original_serializers = ActiveJob::Serializers.serializers + end + + teardown do + ActiveJob::Serializers._additional_serializers = @original_serializers end test "can't serialize unknown object" do @@ -51,14 +55,14 @@ class SerializersTest < ActiveSupport::TestCase end test "adds new serializer" do - ActiveJob::Base.add_serializers DummySerializer - assert ActiveJob::Base.serializers.include?(DummySerializer) + ActiveJob::Serializers.add_serializers DummySerializer + assert ActiveJob::Serializers.serializers.include?(DummySerializer) end test "can't add serializer with the same key twice" do - ActiveJob::Base.add_serializers DummySerializer + ActiveJob::Serializers.add_serializers DummySerializer assert_raises ArgumentError do - ActiveJob::Base.add_serializers DummySerializer + ActiveJob::Serializers.add_serializers DummySerializer end end end -- cgit v1.2.3 From ea615332452e6860872020aa161c5d34e81f1eea Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafael=20Mendon=C3=A7a=20Fran=C3=A7a?= Date: Fri, 9 Feb 2018 15:23:05 -0500 Subject: Only add one more custom key in the serialized hash Now custom serialziers can register itself in the serialized hash using the "_aj_serialized" key that constains the serializer name. This way we can avoid poluting the hash with many reserved keys. --- activejob/test/cases/serializers_test.rb | 31 +++++++++++++++++++++++-------- 1 file changed, 23 insertions(+), 8 deletions(-) (limited to 'activejob/test/cases') diff --git a/activejob/test/cases/serializers_test.rb b/activejob/test/cases/serializers_test.rb index 3b526c932b..fb0e6ecae6 100644 --- a/activejob/test/cases/serializers_test.rb +++ b/activejob/test/cases/serializers_test.rb @@ -10,20 +10,20 @@ class SerializersTest < ActiveSupport::TestCase def initialize(value) @value = value end + + def ==(other) + self.value == other.value + end end class DummySerializer < ActiveJob::Serializers::ObjectSerializer class << self def serialize(object) - { key => object.value } + super({ "value" => object.value }) end def deserialize(hash) - DummyValueObject.new(hash[key]) - end - - def key - "_dummy_serializer" + DummyValueObject.new(hash["value"]) end private @@ -49,9 +49,24 @@ class SerializersTest < ActiveSupport::TestCase end end + test "will serialize objects with serializers registered" do + ActiveJob::Serializers.add_serializers DummySerializer + + assert_equal( + { "_aj_serialized" => "SerializersTest::DummySerializer", "value" => 123 }, + ActiveJob::Serializers.serialize(@value_object) + ) + end + test "won't deserialize unknown hash" do hash = { "_dummy_serializer" => 123, "_aj_symbol_keys" => [] } - assert ActiveJob::Serializers.deserialize(hash), hash.except("_aj_symbol_keys") + assert_equal({ "_dummy_serializer" => 123 }, ActiveJob::Serializers.deserialize(hash)) + end + + test "will deserialize know serialized objects" do + ActiveJob::Serializers.add_serializers DummySerializer + hash = { "_aj_serialized" => "SerializersTest::DummySerializer", "value" => 123 } + assert_equal DummyValueObject.new(123), ActiveJob::Serializers.deserialize(hash) end test "adds new serializer" do @@ -61,7 +76,7 @@ class SerializersTest < ActiveSupport::TestCase test "can't add serializer with the same key twice" do ActiveJob::Serializers.add_serializers DummySerializer - assert_raises ArgumentError do + assert_no_difference(-> { ActiveJob::Serializers.serializers.size } ) do ActiveJob::Serializers.add_serializers DummySerializer end end -- cgit v1.2.3 From b098584f63521d214c1107e6eaa24f292b8e4df8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafael=20Mendon=C3=A7a=20Fran=C3=A7a?= Date: Fri, 9 Feb 2018 15:45:11 -0500 Subject: Add symbol and duration serializers --- activejob/test/cases/argument_serialization_test.rb | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'activejob/test/cases') diff --git a/activejob/test/cases/argument_serialization_test.rb b/activejob/test/cases/argument_serialization_test.rb index 13e6fcb727..442384f2c3 100644 --- a/activejob/test/cases/argument_serialization_test.rb +++ b/activejob/test/cases/argument_serialization_test.rb @@ -13,6 +13,7 @@ class ArgumentSerializationTest < ActiveSupport::TestCase [ nil, 1, 1.0, 1_000_000_000_000_000_000_000, "a", true, false, BigDecimal.new(5), + :a, 1.day, [ 1, "a" ], { "a" => 1 } ].each do |arg| @@ -21,7 +22,7 @@ class ArgumentSerializationTest < ActiveSupport::TestCase end end - [ :a, Object.new, self, Person.find("5").to_gid ].each do |arg| + [ Object.new, self, Person.find("5").to_gid ].each do |arg| test "does not serialize #{arg.class}" do assert_raises ActiveJob::SerializationError do ActiveJob::Arguments.serialize [ arg ] -- cgit v1.2.3 From d2d98d69468bf34a39794496beb8f9f7b69088c4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafael=20Mendon=C3=A7a=20Fran=C3=A7a?= Date: Fri, 9 Feb 2018 16:32:35 -0500 Subject: Allow serializers to be used either as classes or objects --- activejob/test/cases/serializers_test.rb | 16 +++++++--------- 1 file changed, 7 insertions(+), 9 deletions(-) (limited to 'activejob/test/cases') diff --git a/activejob/test/cases/serializers_test.rb b/activejob/test/cases/serializers_test.rb index fb0e6ecae6..207ae55b49 100644 --- a/activejob/test/cases/serializers_test.rb +++ b/activejob/test/cases/serializers_test.rb @@ -17,21 +17,19 @@ class SerializersTest < ActiveSupport::TestCase end class DummySerializer < ActiveJob::Serializers::ObjectSerializer - class << self - def serialize(object) - super({ "value" => object.value }) - end + def serialize(object) + super({ "value" => object.value }) + end - def deserialize(hash) - DummyValueObject.new(hash["value"]) - end + def deserialize(hash) + DummyValueObject.new(hash["value"]) + end - private + private def klass DummyValueObject end - end end setup do -- cgit v1.2.3 From d9a5c7011f62dd771a2fa430090e068b1f9785f3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafael=20Mendon=C3=A7a=20Fran=C3=A7a?= Date: Fri, 9 Feb 2018 16:50:57 -0500 Subject: Add serializers for Time, Date and DateTime --- activejob/test/cases/argument_serialization_test.rb | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'activejob/test/cases') diff --git a/activejob/test/cases/argument_serialization_test.rb b/activejob/test/cases/argument_serialization_test.rb index 442384f2c3..8f51a2d238 100644 --- a/activejob/test/cases/argument_serialization_test.rb +++ b/activejob/test/cases/argument_serialization_test.rb @@ -13,7 +13,9 @@ class ArgumentSerializationTest < ActiveSupport::TestCase [ nil, 1, 1.0, 1_000_000_000_000_000_000_000, "a", true, false, BigDecimal.new(5), - :a, 1.day, + :a, 1.day, Date.new(2001, 2, 3), Time.new(2002, 10, 31, 2, 2, 2, "+02:00"), + DateTime.new(2001, 2, 3, 4, 5, 6, '+03:00'), + ActiveSupport::TimeWithZone.new(Time.utc(1999, 12, 31, 23, 59, 59), ActiveSupport::TimeZone["UTC"]), [ 1, "a" ], { "a" => 1 } ].each do |arg| -- cgit v1.2.3 From 69645cba727dfa1c18c666d2a2f1c0dedffde938 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafael=20Mendon=C3=A7a=20Fran=C3=A7a?= Date: Mon, 12 Feb 2018 14:16:41 -0500 Subject: Simplify the implementation of custom argument serializers We can speed up things for the supported types by keeping the code in the way it was. We can also avoid to loop trough all serializers in the deserialization by trying to access the class already in the Hash. We could also speed up the custom serialization if we define the class that is going to be serialized when registering the serializers, but that will remove the possibility of defining a serialzer for a superclass and have the subclass serialized using it. --- activejob/test/cases/argument_serialization_test.rb | 2 +- activejob/test/cases/serializers_test.rb | 21 +++++++++++++++++++-- 2 files changed, 20 insertions(+), 3 deletions(-) (limited to 'activejob/test/cases') diff --git a/activejob/test/cases/argument_serialization_test.rb b/activejob/test/cases/argument_serialization_test.rb index 8f51a2d238..4e26b9a178 100644 --- a/activejob/test/cases/argument_serialization_test.rb +++ b/activejob/test/cases/argument_serialization_test.rb @@ -14,7 +14,7 @@ class ArgumentSerializationTest < ActiveSupport::TestCase [ nil, 1, 1.0, 1_000_000_000_000_000_000_000, "a", true, false, BigDecimal.new(5), :a, 1.day, Date.new(2001, 2, 3), Time.new(2002, 10, 31, 2, 2, 2, "+02:00"), - DateTime.new(2001, 2, 3, 4, 5, 6, '+03:00'), + DateTime.new(2001, 2, 3, 4, 5, 6, "+03:00"), ActiveSupport::TimeWithZone.new(Time.utc(1999, 12, 31, 23, 59, 59), ActiveSupport::TimeZone["UTC"]), [ 1, "a" ], { "a" => 1 } diff --git a/activejob/test/cases/serializers_test.rb b/activejob/test/cases/serializers_test.rb index 207ae55b49..a86f168d03 100644 --- a/activejob/test/cases/serializers_test.rb +++ b/activejob/test/cases/serializers_test.rb @@ -58,7 +58,24 @@ class SerializersTest < ActiveSupport::TestCase test "won't deserialize unknown hash" do hash = { "_dummy_serializer" => 123, "_aj_symbol_keys" => [] } - assert_equal({ "_dummy_serializer" => 123 }, ActiveJob::Serializers.deserialize(hash)) + error = assert_raises(ArgumentError) do + ActiveJob::Serializers.deserialize(hash) + end + assert_equal( + 'Serializer name is not present in the argument: {"_dummy_serializer"=>123, "_aj_symbol_keys"=>[]}', + error.message + ) + end + + test "won't deserialize unknown serializer" do + hash = { "_aj_serialized" => "DoNotExist", "value" => 123 } + error = assert_raises(ArgumentError) do + ActiveJob::Serializers.deserialize(hash) + end + assert_equal( + "Serializer DoNotExist is not know", + error.message + ) end test "will deserialize know serialized objects" do @@ -74,7 +91,7 @@ class SerializersTest < ActiveSupport::TestCase test "can't add serializer with the same key twice" do ActiveJob::Serializers.add_serializers DummySerializer - assert_no_difference(-> { ActiveJob::Serializers.serializers.size } ) do + assert_no_difference(-> { ActiveJob::Serializers.serializers.size }) do ActiveJob::Serializers.add_serializers DummySerializer end end -- cgit v1.2.3 From b59c7c7e69144bafd6d45f1be68f885e8995b6f1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafael=20Mendon=C3=A7a=20Fran=C3=A7a?= Date: Mon, 12 Feb 2018 22:36:51 -0500 Subject: Add tests to serialize and deserialze individually This will make easier to be backwards compatible when changing the serialization implementation. --- .../test/cases/argument_serialization_test.rb | 43 ++++++++++++++++++++++ 1 file changed, 43 insertions(+) (limited to 'activejob/test/cases') diff --git a/activejob/test/cases/argument_serialization_test.rb b/activejob/test/cases/argument_serialization_test.rb index 4e26b9a178..ff6ac6fc43 100644 --- a/activejob/test/cases/argument_serialization_test.rb +++ b/activejob/test/cases/argument_serialization_test.rb @@ -49,6 +49,49 @@ class ArgumentSerializationTest < ActiveSupport::TestCase assert_arguments_roundtrip([a: 1, "b" => 2]) end + test "serialize a hash" do + symbol_key = { a: 1 } + string_key = { "a" => 1 } + indifferent_access = { a: 1 }.with_indifferent_access + + assert_equal( + { "a" => 1, "_aj_symbol_keys" => ["a"] }, + ActiveJob::Arguments.serialize([symbol_key]).first + ) + assert_equal( + { "a" => 1, "_aj_symbol_keys" => [] }, + ActiveJob::Arguments.serialize([string_key]).first + ) + assert_equal( + { "a" => 1, "_aj_hash_with_indifferent_access" => true }, + ActiveJob::Arguments.serialize([indifferent_access]).first + ) + end + + test "deserialize a hash" do + symbol_key = { "a" => 1, "_aj_symbol_keys" => ["a"] } + string_key = { "a" => 1, "_aj_symbol_keys" => [] } + another_string_key = { "a" => 1 } + indifferent_access = { "a" => 1, "_aj_hash_with_indifferent_access" => true } + + assert_equal( + { a: 1 }, + ActiveJob::Arguments.deserialize([symbol_key]).first + ) + assert_equal( + { "a" => 1 }, + ActiveJob::Arguments.deserialize([string_key]).first + ) + assert_equal( + { "a" => 1 }, + ActiveJob::Arguments.deserialize([another_string_key]).first + ) + assert_equal( + { "a" => 1 }, + ActiveJob::Arguments.deserialize([indifferent_access]).first + ) + end + test "should maintain hash with indifferent access" do symbol_key = { a: 1 } string_key = { "a" => 1 } -- cgit v1.2.3 From d2c094aa5081677bf537a1553d0a756fcafcfb4e Mon Sep 17 00:00:00 2001 From: bogdanvlviv Date: Sat, 17 Feb 2018 00:15:11 +0200 Subject: Add argument serializer `TimeWithZoneSerializer` The serializer serializes an instance of `ActiveSupport::TimeWithZone`. The serializer deserializes value to `ActiveSupport::TimeWithZone` if possible. --- activejob/test/cases/argument_serialization_test.rb | 8 ++++++++ 1 file changed, 8 insertions(+) (limited to 'activejob/test/cases') diff --git a/activejob/test/cases/argument_serialization_test.rb b/activejob/test/cases/argument_serialization_test.rb index ff6ac6fc43..1daccd40c4 100644 --- a/activejob/test/cases/argument_serialization_test.rb +++ b/activejob/test/cases/argument_serialization_test.rb @@ -102,6 +102,14 @@ class ArgumentSerializationTest < ActiveSupport::TestCase assert_instance_of ActiveSupport::HashWithIndifferentAccess, perform_round_trip([indifferent_access]).first end + test "should maintain time with zone" do + Time.use_zone "Alaska" do + time_with_zone = Time.new(2002, 10, 31, 2, 2, 2).in_time_zone + assert_instance_of ActiveSupport::TimeWithZone, perform_round_trip([time_with_zone]).first + assert_arguments_unchanged time_with_zone + end + end + test "should disallow non-string/symbol hash keys" do assert_raises ActiveJob::SerializationError do ActiveJob::Arguments.serialize [ { 1 => 2 } ] -- cgit v1.2.3 From 67391879f606e4ad9ef64210a23431e071b3df8c Mon Sep 17 00:00:00 2001 From: bogdanvlviv Date: Sat, 17 Feb 2018 00:45:17 +0200 Subject: Fix error message about unknown `ActiveJob` argument serializer --- activejob/test/cases/serializers_test.rb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'activejob/test/cases') diff --git a/activejob/test/cases/serializers_test.rb b/activejob/test/cases/serializers_test.rb index a86f168d03..bee0c061bd 100644 --- a/activejob/test/cases/serializers_test.rb +++ b/activejob/test/cases/serializers_test.rb @@ -73,7 +73,7 @@ class SerializersTest < ActiveSupport::TestCase ActiveJob::Serializers.deserialize(hash) end assert_equal( - "Serializer DoNotExist is not know", + "Serializer DoNotExist is not known", error.message ) end -- cgit v1.2.3 From 7d2b8f3ac98e11ab34e3395dd921984b8dd61e9a Mon Sep 17 00:00:00 2001 From: "yuuji.yaginuma" Date: Sun, 18 Feb 2018 09:59:58 +0900 Subject: Fix "warning: BigDecimal.new is deprecated" --- activejob/test/cases/argument_serialization_test.rb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'activejob/test/cases') diff --git a/activejob/test/cases/argument_serialization_test.rb b/activejob/test/cases/argument_serialization_test.rb index ff6ac6fc43..5d27813832 100644 --- a/activejob/test/cases/argument_serialization_test.rb +++ b/activejob/test/cases/argument_serialization_test.rb @@ -12,7 +12,7 @@ class ArgumentSerializationTest < ActiveSupport::TestCase end [ nil, 1, 1.0, 1_000_000_000_000_000_000_000, - "a", true, false, BigDecimal.new(5), + "a", true, false, BigDecimal(5), :a, 1.day, Date.new(2001, 2, 3), Time.new(2002, 10, 31, 2, 2, 2, "+02:00"), DateTime.new(2001, 2, 3, 4, 5, 6, "+03:00"), ActiveSupport::TimeWithZone.new(Time.utc(1999, 12, 31, 23, 59, 59), ActiveSupport::TimeZone["UTC"]), -- cgit v1.2.3 From a9d1167b1fdae6f5f5496738b3e7d1e05949dcd0 Mon Sep 17 00:00:00 2001 From: Andrew White Date: Thu, 22 Feb 2018 14:14:42 +0000 Subject: Add support for timezones to Active Job Record what was the current timezone in effect when the job was enqueued and then restore when the job is executed in same way that the current locale is recorded and restored. --- activejob/test/cases/job_serialization_test.rb | 7 +++++++ activejob/test/cases/timezones_test.rb | 24 ++++++++++++++++++++++++ 2 files changed, 31 insertions(+) create mode 100644 activejob/test/cases/timezones_test.rb (limited to 'activejob/test/cases') diff --git a/activejob/test/cases/job_serialization_test.rb b/activejob/test/cases/job_serialization_test.rb index 440051c427..5c9994508e 100644 --- a/activejob/test/cases/job_serialization_test.rb +++ b/activejob/test/cases/job_serialization_test.rb @@ -54,4 +54,11 @@ class JobSerializationTest < ActiveSupport::TestCase job.provider_job_id = "some value set by adapter" assert_equal job.provider_job_id, job.serialize["provider_job_id"] end + + test "serialize stores the current timezone" do + Time.use_zone "Hawaii" do + job = HelloJob.new + assert_equal "Hawaii", job.serialize["timezone"] + end + end end diff --git a/activejob/test/cases/timezones_test.rb b/activejob/test/cases/timezones_test.rb new file mode 100644 index 0000000000..e2095b020d --- /dev/null +++ b/activejob/test/cases/timezones_test.rb @@ -0,0 +1,24 @@ +# frozen_string_literal: true + +require "helper" +require "jobs/timezone_dependent_job" + +class TimezonesTest < ActiveSupport::TestCase + setup do + JobBuffer.clear + end + + test "it performs the job in the given timezone" do + job = TimezoneDependentJob.new("2018-01-01T00:00:00Z") + job.timezone = "London" + job.perform_now + + assert_equal "Happy New Year!", JobBuffer.last_value + + job = TimezoneDependentJob.new("2018-01-01T00:00:00Z") + job.timezone = "Eastern Time (US & Canada)" + job.perform_now + + assert_equal "Just 5 hours to go", JobBuffer.last_value + end +end -- cgit v1.2.3