trailblazer-context 0.2.0 → 0.4.0

data/lib/trailblazer/context/store/indifferent_access.rb

@@ -0,0 +1,36 @@
+require "hashie"
+
+module Trailblazer
+  module Context
+    module Store
+      # Simple yet indifferently accessible hash store, used as replica in Context::Container.
+      # It maintains cache for multiple hashes (wrapped_options, mutable_options etc).
+      class IndifferentAccess < Hash
+        include Hashie::Extensions::IndifferentAccess
+
+        def initialize(hashes)
+          hashes.each do |hash|
+            hash.each do |key, value|
+              self[key] = value
+            end
+          end
+        end
+
+        # Override of Hashie::Extensions::IndifferentAccess#indifferent_value
+        # to not do deep indifferent access conversion.
+        # DISCUSS: Should we make this configurable ?
+        def indifferent_value(value)
+          value
+        end
+
+        # Override of Hashie::Extensions::IndifferentAccess#convert_key
+        # to store keys as Symbol by default instead of String.
+        # Why ? We need to pass `ctx` as keyword arguments most of the time.
+        def convert_key(key)
+          return key if Symbol === key 
+          String === key ? key.to_sym : key
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/context/version.rb

@@ -1,5 +1,5 @@
 module Trailblazer
-  class Context
-    VERSION = "0.2.0"
+  module Context
+    VERSION = "0.4.0"
   end
 end

data/lib/trailblazer/option.rb

@@ -1,78 +1,47 @@
 module Trailblazer
-  # @note This might go to trailblazer-args along with `Context` at some point.
-  def self.Option(proc)
-    Option.build(Option, proc)
-  end
-
   class Option
-    # Generic builder for a callable "option".
-    # @param call_implementation [Class, Module] implements the process of calling the proc
-    #   while passing arguments/options to it in a specific style (e.g. kw args, step interface).
-    # @return [Proc] when called, this proc will evaluate its option (at run-time).
-    def self.build(call_implementation, proc)
-      if proc.is_a? Symbol
-        ->(*args, &block) { call_implementation.evaluate_method(proc, *args, &block) }
-      else
-        ->(*args, &block) { call_implementation.evaluate_callable(proc, *args, &block) }
-      end
-    end
-
     # A call implementation invoking `proc.(*args)` and plainly forwarding all arguments.
     # Override this for your own step strategy (see KW#call!).
     # @private
-    def self.call!(proc, *args, &block)
-      proc.(*args, &block)
+    def self.call!(proc, *args, keyword_arguments: {}, **, &block)
+      # {**keyword_arguments} gets removed automatically if it's an empty hash.
+      # DISCUSS: is this a good practice?
+      proc.(*args, **keyword_arguments, &block)
     end
 
     # Note that both #evaluate_callable and #evaluate_method drop most of the args.
     # If you need those, override this class.
     # @private
-    def self.evaluate_callable(proc, *args, **circuit_options, &block)
-      call!(proc, *args, &block)
+    def self.evaluate_callable(proc, *args, **options, &block)
+      call!(proc, *args, **options, &block)
     end
 
     # Make the context's instance method a "lambda" and reuse #call!.
     # @private
-    def self.evaluate_method(proc, *args, exec_context: raise("No :exec_context given."), **circuit_options, &block)
-      call!(exec_context.method(proc), *args, &block)
+    def self.evaluate_method(proc, *args, exec_context: raise("No :exec_context given."), **options, &block)
+      call!(exec_context.method(proc), *args, **options, &block)
     end
 
-    # Returns a {Proc} that, when called, invokes the `proc` argument with keyword arguments.
-    # This is known as "step (call) interface".
-    #
-    # This is commonly used by `Operation::step` to wrap the argument and make it
-    # callable in the circuit.
-    #
-    #   my_proc = ->(options, **kws) { options["i got called"] = true }
-    #   task    = Trailblazer::Option::KW(my_proc)
-    #   task.(options = {})
-    #   options["i got called"] #=> true
-    #
-    # Alternatively, you can pass a symbol and an `:exec_context`.
-    #
-    #   my_proc = :some_method
-    #   task    = Trailblazer::Option::KW(my_proc)
-    #
-    #   class A
-    #     def some_method(options, **kws)
-    #       options["i got called"] = true
-    #     end
-    #   end
-    #
-    #   task.(options = {}, exec_context: A.new)
-    #   options["i got called"] #=> true
-    def self.KW(proc)
-      Option.build(KW, proc)
+    # Generic builder for a callable "option".
+    # @param call_implementation [Class, Module] implements the process of calling the proc
+    #   while passing arguments/options to it in a specific style (e.g. kw args, step interface).
+    # @return [Proc] when called, this proc will evaluate its option (at run-time).
+    def self.build(proc)
+      if proc.is_a? Symbol
+        ->(*args, **kws, &block) { Option.evaluate_method(proc, *args, **kws, &block) }
+      else
+        ->(*args, **kws, &block) {
+          Option.evaluate_callable(proc, *args, **kws, &block) }
+      end
     end
 
-    # TODO: It would be cool if call! was typed and had `options SymbolizedHash` or something.
-    class KW < Option
-      # A different call implementation that calls `proc` with a "step interface".
-      #   your_code.(options, **options)
-      # @private
-      def self.call!(proc, options, *)
-        proc.(options, **options.to_hash) # Step interface: (options, **)
-      end
+    def self.KW(proc)
+      raise "The `Option::KW()` method has been removed in trailblazer-context-0.4.
+Please use `Option(task, keyword_arguments: {...})` instead. Check https://trailblazer.to/2.1/docs/trailblazer.html#trailblazer-context-option"
     end
   end
+  # @note This might go to trailblazer-args along with `Context` at some point.
+  def self.Option(proc)
+    Option.build(proc)
+  end
 end

data/test/benchmark/benchmark_helper.rb

@@ -0,0 +1,32 @@
+require 'test_helper'
+require 'benchmark/ips'
+
+BenchmarkRepresenter = Struct.new(:benchmark, :times_slower)
+
+Minitest::Spec.class_eval do
+  def benchmark_ips(records, time: 1, warmup: 1)
+    base    = records[:base]
+    target  = records[:target]
+
+    benchmark = Benchmark.ips do |x|
+      x.config(time: time, warmup: warmup)
+
+      x.report(base[:label], &base[:block])
+      x.report(target[:label], &target[:block])
+
+      x.compare!
+    end
+
+    times_slower = benchmark.data[0][:ips] / benchmark.data[1][:ips]
+    BenchmarkRepresenter.new(benchmark, times_slower)
+  end
+
+  def assert_times_slower(result, threshold)
+    base    = result.benchmark.data[0]
+    target  = result.benchmark.data[1]
+
+    msg = "Expected #{target[:name]} to be slower by at most #{threshold} times than #{base[:name]}, but got #{result.times_slower}"
+
+    assert result.times_slower < threshold, msg
+  end
+end

data/test/benchmark/indifferent_access_test.rb

@@ -0,0 +1,89 @@
+require_relative "benchmark_helper"
+
+describe "Context::IndifferentAccess Performance" do
+  wrapped_options = { model: Object, policy: Hash, representer: String }
+  mutable_options = { write: String, read: Integer, delete: Float, merge: Symbol }
+  context_options = {
+    container_class: Trailblazer::Context::Container,
+    replica_class: Trailblazer::Context::Store::IndifferentAccess,
+  }
+
+  default_hash      = Hash(**wrapped_options, **mutable_options)
+  indifferent_hash  = Trailblazer::Context.build(wrapped_options, mutable_options, context_options)
+
+  it "initialize" do
+    result = benchmark_ips(
+      base: { label: :initialize_default_hash, block: ->{
+        Hash(**wrapped_options, **mutable_options)
+      }},
+      target: { label: :initialize_indifferent_hash, block: ->{
+        Trailblazer::Context.build(wrapped_options, mutable_options, context_options)
+      }},
+    )
+
+    assert_times_slower result, 3
+  end
+
+  it "read" do
+    result = benchmark_ips(
+      base: { label: :read_from_default_hash, block: ->{ default_hash[:read] } },
+      target: { label: :read_from_indifferent_hash, block: ->{ indifferent_hash[:read] } },
+    )
+
+    assert_times_slower result, 1.4
+  end
+
+  it "unknown read" do
+    result = benchmark_ips(
+      base: { label: :unknown_read_from_default_hash, block: ->{ default_hash[:unknown] } },
+      target: { label: :unknown_read_from_indifferent_hash, block: ->{ indifferent_hash[:unknown] } },
+    )
+
+    assert_times_slower result, 3.5
+  end
+
+  it "write" do
+    result = benchmark_ips(
+      base: { label: :write_to_default_hash, block: ->{ default_hash[:write] = "" } },
+      target: { label: :write_to_indifferent_hash, block: ->{ indifferent_hash[:write] = "SKU-1" } },
+    )
+
+    assert_times_slower result, 2.3
+  end
+
+  it "delete" do
+    result = benchmark_ips(
+      base: { label: :delete_from_default_hash, block: ->{ default_hash.delete(:delete) } },
+      target: { label: :delete_from_indifferent_hash, block: ->{ indifferent_hash.delete(:delete) } },
+    )
+
+    assert_times_slower result, 2.4
+  end
+
+  it "merge" do
+    result = benchmark_ips(
+      base: { label: :merge_from_default_hash, block: ->{ default_hash.merge(merge: :object_id) } },
+      target: { label: :merge_from_indifferent_hash, block: ->{ indifferent_hash.merge(merge: :object_id) } },
+    )
+
+    assert_times_slower result, 5.55
+  end
+
+  it "to_hash" do
+    result = benchmark_ips(
+      base: { label: :default_to_hash, block: ->{ default_hash.to_hash } },
+      target: { label: :indifferent_to_hash, block: ->{ indifferent_hash.to_hash } },
+    )
+
+    assert_times_slower result, 1.3
+  end
+
+  it "decompose" do
+    result = benchmark_ips(
+      base: { label: :dup_default_hash, block: ->{ default_hash.to_hash } },
+      target: { label: :decompose, block: ->{ indifferent_hash.decompose } },
+    )
+
+    assert_times_slower result, 1.55
+  end
+end

data/test/benchmark/indifferent_access_with_aliasing_test.rb

@@ -0,0 +1,73 @@
+require_relative "benchmark_helper"
+
+describe "Context::Aliasing Performance" do
+  wrapped_options = { model: Object, policy: Hash, representer: String }
+  mutable_options = { write: String, read: Integer, delete: Float, merge: Symbol }
+
+  context_options = {
+    container_class: Trailblazer::Context::Container::WithAliases,
+    replica_class: Trailblazer::Context::Store::IndifferentAccess,
+    aliases: { read: :reader }
+  }
+
+  default_hash  = Hash(**wrapped_options, **mutable_options)
+  aliased_hash  = Trailblazer::Context.build(wrapped_options, mutable_options, context_options)
+
+  it "initialize" do
+    result = benchmark_ips(
+      base: { label: :initialize_default_hash, block: ->{
+        Hash(**wrapped_options, **mutable_options)
+      }},
+      target: { label: :initialize_aliased_hash, block: ->{
+        Trailblazer::Context.build(wrapped_options, mutable_options, context_options)
+      }},
+    )
+
+    assert_times_slower result, 8
+  end
+
+  it "write" do
+    result = benchmark_ips(
+      base: { label: :write_to_default_hash, block: ->{ default_hash[:write] = "" } },
+      target: { label: :write_to_aliased_hash, block: ->{ aliased_hash[:write] = "" } },
+    )
+
+    assert_times_slower result, 3.66
+  end
+
+  it "read" do
+    result = benchmark_ips(
+      base: { label: :read_from_default_hash, block: ->{ default_hash[:read] } },
+      target: { label: :read_from_aliased_hash, block: ->{ aliased_hash[:reader] } },
+    )
+
+    assert_times_slower result, 1.5
+  end
+
+  it "delete" do
+    result = benchmark_ips(
+      base: { label: :delete_from_default_hash, block: ->{ default_hash.delete(:delete) } },
+      target: { label: :delete_from_aliased_hash, block: ->{ aliased_hash.delete(:delete) } },
+    )
+
+    assert_times_slower result, 4
+  end
+
+  it "merge" do
+    result = benchmark_ips(
+      base: { label: :merge_from_default_hash, block: ->{ default_hash.merge(merge: :object_id) } },
+      target: { label: :merge_from_aliased_hash, block: ->{ aliased_hash.merge(merge: :object_id) } },
+    )
+
+    assert_times_slower result, 8.5
+  end
+
+  it "to_hash" do
+    result = benchmark_ips(
+      base: { label: :default_to_hash, block: ->{ default_hash.to_hash } },
+      target: { label: :aliased_to_hash, block: ->{ aliased_hash.to_hash } },
+    )
+
+    assert_times_slower result, 1.5
+  end
+end

data/test/context_test.rb

@@ -2,8 +2,6 @@ require "test_helper"
 require "trailblazer/container_chain"
 
 class ArgsTest < Minitest::Spec
-  Context = Trailblazer::Context
-
   let(:immutable) { {repository: "User"} }
 
   let(:ctx) { Trailblazer::Context(immutable) }
@@ -16,16 +14,17 @@ class ArgsTest < Minitest::Spec
     # options[] and options[]=
     ctx[:model]    = Module
     ctx[:contract] = Integer
-    ctx[:model]   .must_equal Module
-    ctx[:contract].must_equal Integer
+    _(ctx[:model])   .must_equal Module
+    _(ctx[:contract]).must_equal Integer
 
     # it {  }
-    immutable.inspect.must_equal %({:repository=>\"User\"})
+    _(immutable.inspect).must_equal %({:repository=>\"User\"})
+    _(ctx.inspect).must_equal %{#<Trailblazer::Context::Container wrapped_options={:repository=>\"User\"} mutable_options={:model=>Module, :contract=>Integer}>}
   end
 
   it "allows false/nil values" do
     ctx["x"] = false
-    ctx["x"].must_equal false
+    _(ctx["x"]).must_equal false
 
     ctx["x"] = nil
     assert_nil ctx["x"]
@@ -36,7 +35,7 @@ class ArgsTest < Minitest::Spec
     ctx = Trailblazer::Context(immutable)
 
     # it {  }
-    ctx.to_hash.must_equal(repository: "User")
+    _(ctx.to_hash).must_equal(repository: "User")
 
     # last added has precedence.
     # only symbol keys.
@@ -44,7 +43,7 @@ class ArgsTest < Minitest::Spec
     ctx[:a] = Symbol
     ctx["a"] = String
 
-    ctx.to_hash.must_equal(repository: "User", a: String)
+    _(ctx.to_hash).must_equal(repository: "User", a: String)
   end
 
   describe "#merge" do
@@ -53,160 +52,271 @@ class ArgsTest < Minitest::Spec
 
       merged = ctx.merge(current_user: Module)
 
-      merged.to_hash.must_equal(repository: "User", current_user: Module)
-      ctx.to_hash.must_equal(repository: "User")
+      _(merged.class).must_equal(Trailblazer::Context::Container)
+      _(merged.to_hash).must_equal(repository: "User", current_user: Module)
+      _(ctx.to_hash).must_equal(repository: "User")
     end
   end
 
-  #-
+  describe "Enumerable behaviour" do
+    it { _(ctx.each.to_a).must_equal [[:repository, "User"]] }
+    it { _(ctx.find{ |k, _| k == :repository }).must_equal [:repository, "User"] }
+    it { _(ctx.inject([]){ |r, (k, _)| r << k}).must_equal [:repository] }
+  end
+
+  #- #decompose
   it do
     immutable = {repository: "User", model: Module, current_user: Class}
+    mutable   = {error: RuntimeError}
 
-    Trailblazer::Context(immutable) do |_original, mutable|
-      mutable
-    end
+    _([immutable, mutable]).must_equal Trailblazer::Context(immutable, mutable).decompose
   end
 end
 
 class ContextWithIndifferentAccessTest < Minitest::Spec
   it do
-    flow_options    = {}
+    flow_options    = {
+      context_options: {
+        container_class: Trailblazer::Context::Container,
+        replica_class: Trailblazer::Context::Store::IndifferentAccess
+      }
+    }
+
     circuit_options = {}
 
     immutable       = {model: Object, "policy" => Hash}
 
-    ctx = Trailblazer::Context.for_circuit(immutable, {}, [immutable, flow_options], circuit_options)
+    ctx = Trailblazer::Context.for_circuit(immutable, {}, [immutable, flow_options], **circuit_options)
 
-    ctx[:model].must_equal Object
-    ctx["model"].must_equal Object
-    ctx[:policy].must_equal Hash
-    ctx["policy"].must_equal Hash
+    _(ctx[:model]).must_equal Object
+    _(ctx["model"]).must_equal Object
+    _(ctx[:policy]).must_equal Hash
+    _(ctx["policy"]).must_equal Hash
 
     ctx["contract.default"] = Module
-    ctx["contract.default"].must_equal Module
-    ctx[:"contract.default"].must_equal Module
+    _(ctx["contract.default"]).must_equal Module
+    _(ctx[:"contract.default"]).must_equal Module
 
 # key?
-    ctx.key?("____contract.default").must_equal false
-    ctx.key?("contract.default").must_equal true
-    ctx.key?(:"contract.default").must_equal true
+    _(ctx.key?("____contract.default")).must_equal false
+    _(ctx.key?("contract.default")).must_equal true
+    _(ctx.key?(:"contract.default")).must_equal true
 
 # context in context
-    ctx2 = Trailblazer::Context.for_circuit(ctx, {}, [ctx, flow_options], circuit_options)
+    ctx2 = Trailblazer::Context.for_circuit(ctx, {}, [ctx, flow_options], **circuit_options)
 
-    ctx2[:model].must_equal Object
-    ctx2["model"].must_equal Object
+    _(ctx2[:model]).must_equal Object
+    _(ctx2["model"]).must_equal Object
 
     ctx2["contract.default"] = Class
-    ctx2["contract.default"].must_equal Class
-    ctx2[:"contract.default"].must_equal Class
+    _(ctx2["contract.default"]).must_equal Class
+    _(ctx2[:"contract.default"]).must_equal Class
 
 # key?
-    ctx2.key?("contract.default").must_equal true
-    ctx2.key?(:"contract.default").must_equal true
-    ctx2.key?("model").must_equal true
+    _(ctx2.key?("contract.default")).must_equal true
+    _(ctx2.key?(:"contract.default")).must_equal true
+    _(ctx2.key?("model")).must_equal true
 
 # wrapped ctx doesn't change
-    ctx["contract.default"].must_equal Module
-    ctx[:"contract.default"].must_equal Module
+    _(ctx["contract.default"]).must_equal Module
+    _(ctx[:"contract.default"]).must_equal Module
 
+# delete
+    ctx[:model] = Object
+    ctx.delete 'model'
+
+    _(ctx.key?(:model)).must_equal false
+    _(ctx.key?("model")).must_equal false
 
     ctx3 = ctx.merge("result" => false)
 
-    ctx3["contract.default"].must_equal Module
-    ctx3[:"contract.default"].must_equal Module
-    ctx3["result"].must_equal false
-    ctx3[:result].must_equal false
-    ctx3.key?("result").must_equal true
-    ctx3.key?(:result).must_equal true
+    _(ctx3["contract.default"]).must_equal Module
+    _(ctx3[:"contract.default"]).must_equal Module
+    _(ctx3["result"]).must_equal false
+    _(ctx3[:result]).must_equal false
+    _(ctx3.key?("result")).must_equal true
+    _(ctx3.key?(:result)).must_equal true
   end
 
   it "Aliasable" do
-    flow_options    = {context_alias: {"contract.default" => :contract, "result.default"=>:result, "trace.stack" => :stack}}
+    flow_options    = {
+      context_options: {
+        container_class: Trailblazer::Context::Container::WithAliases,
+        replica_class: Trailblazer::Context::Store::IndifferentAccess,
+        aliases: { "contract.default" => :contract, "result.default"=>:result, "trace.stack" => :stack }
+      }
+    }
+
     circuit_options = {}
 
     immutable       = {model: Object, "policy" => Hash}
 
-    ctx = Trailblazer::Context.for_circuit(immutable, {}, [immutable, flow_options], circuit_options)
+    ctx = Trailblazer::Context.for_circuit(immutable, {}, [immutable, flow_options], **circuit_options)
+    _(ctx.class).must_equal(Trailblazer::Context::Container::WithAliases)
+
+    _(ctx.inspect).must_equal %{#<Trailblazer::Context::Container::WithAliases wrapped_options={:model=>Object, \"policy\"=>Hash} mutable_options={} aliases={\"contract.default\"=>:contract, \"result.default\"=>:result, \"trace.stack\"=>:stack}>}
+
+    _(ctx.to_hash).must_equal(:model=>Object, :policy=>Hash)
 
-    ctx[:model].must_equal Object
-    ctx["model"].must_equal Object
-    ctx[:policy].must_equal Hash
-    ctx["policy"].must_equal Hash
+    _(ctx[:model]).must_equal Object
+    _(ctx["model"]).must_equal Object
+    _(ctx[:policy]).must_equal Hash
+    _(ctx["policy"]).must_equal Hash
 
     ctx["contract.default"] = Module
-    ctx["contract.default"].must_equal Module
-    ctx[:"contract.default"].must_equal Module
+    _(ctx["contract.default"]).must_equal Module
+    _(ctx[:"contract.default"]).must_equal Module
 
     # alias
-    ctx[:result].must_equal nil
-    ctx["result"].must_equal nil
+    assert_nil ctx[:result]
+    assert_nil ctx["result"]
 
-    ctx[:contract].must_equal Module
+    _(ctx[:contract]).must_equal Module
+    _(ctx['contract']).must_equal Module
 
-    ctx[:stack].must_equal nil
+    assert_nil ctx[:stack]
+    assert_nil ctx['stack']
 
   # Set an aliased property via setter
     ctx["trace.stack"] = Object
-    ctx[:stack].must_equal Object
-    ctx["trace.stack"].must_equal Object
+    _(ctx[:stack]).must_equal Object
+    _(ctx["stack"]).must_equal Object
+    _(ctx["trace.stack"]).must_equal Object
+
+  # Set an aliased property with merge
+    ctx["trace.stack"] = String
+    merged = ctx.merge(stack: Integer)
+
+    _(merged.class).must_equal(Trailblazer::Context::Container::WithAliases)
+    _(merged.to_hash).must_equal(:model=>Object, :policy=>Hash, :contract=>Module, :"contract.default"=>Module, :stack=>Integer, :"trace.stack"=>Integer)
 
 # key?
-    ctx.key?("____contract.default").must_equal false
-    ctx.key?("contract.default").must_equal true
-    ctx.key?(:"contract.default").must_equal true
-    ctx.key?(:contract).must_equal true
-    ctx.key?(:result).must_equal false
-    ctx.key?(:stack).must_equal true
-    ctx.key?("trace.stack").must_equal true
-    ctx.key?(:"trace.stack").must_equal true
+    _(ctx.key?("____contract.default")).must_equal false
+    _(ctx.key?("contract.default")).must_equal true
+    _(ctx.key?(:"contract.default")).must_equal true
+    _(ctx.key?(:contract)).must_equal true
+    _(ctx.key?(:result)).must_equal false
+    _(ctx.key?(:stack)).must_equal true
+    _(ctx.key?("trace.stack")).must_equal true
+    _(ctx.key?(:"trace.stack")).must_equal true
+
+# delete
+    ctx[:result] = Object
+    ctx.delete :result
+
+    _(ctx.key?(:result)).must_equal false
+    _(ctx.key?("result")).must_equal false
+
+    _(ctx.key?(:"result.default")).must_equal false
+    _(ctx.key?("result.default")).must_equal false
+
 
 # to_hash
-    ctx.to_hash.must_equal(:model=>Object, :policy=>Hash, :"contract.default"=>Module, :"trace.stack"=>Object, :contract=>Module, :stack=>Object)
+    _(ctx.to_hash).must_equal(:model=>Object, :policy=>Hash, :contract=>Module, :"contract.default"=>Module, :stack=>String, :"trace.stack"=>String)
 
 # context in context
-    ctx2 = Trailblazer::Context.for_circuit(ctx, {}, [ctx, flow_options], circuit_options)
-
-    ctx2.key?("____contract.default").must_equal false
-    ctx2.key?("contract.default").must_equal true
-    ctx2.key?(:"contract.default").must_equal true
-    ctx2.key?(:contract).must_equal true
-    ctx2.key?(:result).must_equal false
-    ctx2.key?("result.default").must_equal false
-    ctx2.key?(:stack).must_equal true
-    ctx2.key?("trace.stack").must_equal true
-    ctx2.key?(:"trace.stack").must_equal true
+    ctx2 = Trailblazer::Context.for_circuit(ctx, {}, [ctx, flow_options], **circuit_options)
+
+    _(ctx2.key?("____contract.default")).must_equal false
+    _(ctx2.key?("contract.default")).must_equal true
+    _(ctx2.key?(:"contract.default")).must_equal true
+    _(ctx2.key?(:contract)).must_equal true
+    _(ctx2.key?(:result)).must_equal false
+    _(ctx2.key?("result.default")).must_equal false
+    _(ctx2.key?(:stack)).must_equal true
+    _(ctx2.key?("trace.stack")).must_equal true
+    _(ctx2.key?(:"trace.stack")).must_equal true
 
   # Set aliased in new context via setter
     ctx2["result.default"] = Class
 
-    ctx2[:result].must_equal Class
-    ctx2[:"result.default"].must_equal Class
+    _(ctx2[:result]).must_equal Class
+    _(ctx2[:"result.default"]).must_equal Class
 
-    ctx2.key?("result.default").must_equal true
-    ctx2.key?(:"result.default").must_equal true
-    ctx2.key?(:result).must_equal true
+    _(ctx2.key?("result.default")).must_equal true
+    _(ctx2.key?(:"result.default")).must_equal true
+    _(ctx2.key?(:result)).must_equal true
 
     # todo: TEST flow_options={context_class: SomethingElse}
   end
 
-  it ".build provides default args" do
-    immutable       = {model: Object, "policy.default" => Hash}
+  it ".build accepts custom container class" do
+    MyContainer = Class.new(Trailblazer::Context::Container) do
+      def inspect
+        %{#<MyContainer wrapped=#{@wrapped_options} mutable=#{@mutable_options}>}
+      end
+    end
+
+    immutable = { model: Object }
+    options   = { container_class: MyContainer, replica_class: Trailblazer::Context::Store::IndifferentAccess }
+
+    ctx = Trailblazer::Context.build(immutable, {}, **options)
+    _(ctx.class).must_equal(MyContainer)
+    _(ctx.inspect).must_equal("#<MyContainer wrapped=#{immutable} mutable={}>")
 
-  # {Aliasing#initialize}
-    ctx = Trailblazer::Context::IndifferentAccess.new(immutable, {}, context_alias: {"policy.default" => :policy})
+    _(ctx.to_hash).must_equal({ model: Object })
 
-    ctx[:model].must_equal Object
-    ctx["model"].must_equal Object
-    ctx[:policy].must_equal Hash
+    ctx[:integer] = Integer
+    _(ctx.to_hash).must_equal({ model: Object, integer: Integer })
+
+    ctx2 = ctx.merge(float: Float)
+    _(ctx2.class).must_equal(MyContainer)
+
+    _(ctx2.to_hash).must_equal({ model: Object, integer: Integer, float: Float })
+  end
+
+  it ".build accepts custom replica class (For example, To opt out from indifferent access)" do
+    MyReplica = Class.new(Hash) do
+      def initialize(*containers)
+        containers.each do |container|
+          container.each{ |key, value| self[key] = value }
+        end
+      end
+    end
+
+    immutable = { model: Object }
+    options   = { container_class: Trailblazer::Context::Container, replica_class: MyReplica }
+
+    ctx = Trailblazer::Context.build(immutable, {}, **options)
+    ctx[:integer] = Integer
+
+    _(ctx[:integer]).must_equal(Integer)
+    _(ctx['integer']).must_be_nil
+  end
+
+  it "Context() provides default args" do
+    immutable = {model: Object, "policy.default" => Hash}
+    options   = {
+      container_class: Trailblazer::Context::Container::WithAliases,
+      aliases: { "policy.default" => :policy }
+    }
+
+    ctx = Trailblazer::Context(immutable, {}, options)
+
+    _(ctx[:model]).must_equal Object
+    _(ctx["model"]).must_equal Object
+    _(ctx[:policy]).must_equal Hash
 
     ctx2 = ctx.merge(result: :success)
 
 
-    ctx2[:model].must_equal Object
-    ctx2["model"].must_equal Object
-    ctx2[:policy].must_equal Hash
-    ctx2[:result].must_equal :success
+    _(ctx2[:model]).must_equal Object
+    _(ctx2["model"]).must_equal Object
+    _(ctx2[:policy]).must_equal Hash
+    _(ctx2[:result]).must_equal :success
+  end
+
+  it "Context() throws RuntimeError if aliases are passed but container_class doesn't support it" do
+    immutable = {model: Object, "policy.default" => Hash}
+    options   = {
+      aliases: { "policy.default" => :policy }
+    }
+
+    exception = assert_raises Trailblazer::Context::Container::UseWithAliases do
+      Trailblazer::Context(immutable, {}, options)
+    end
+
+    _(exception.message).must_equal %{Pass `Trailblazer::Context::Container::WithAliases` as `container_class` while defining `aliases`}
   end
 end