foobara 0.5.10 → 0.6.2

data/projects/typesystem/spec/types/type_spec.rb

@@ -1,102 +0,0 @@
-RSpec.describe Foobara::Types do
-  let(:type) { Foobara::Domain.current.foobara_type_from_declaration(type_declaration) }
-
-  context "when created from scratch" do
-    let(:type) do
-      Foobara::Types::Type.new(
-        "whatever",
-        base_type: nil,
-        target_classes: [Object]
-      )
-    end
-
-    it "has no scoped path set" do
-      expect(type).to_not be_scoped_path_set
-    end
-  end
-
-  context "when :attributes" do
-    let(:type_declaration) { { foo: :duck } }
-
-    describe "#cast_from" do
-      let(:outcome) { type.process_value(hash) }
-      let(:result) { outcome.result }
-      let(:errors) { outcome.errors }
-
-      context "when hash has symbolic keys" do
-        let(:hash) { { foo: "bar" } }
-
-        it "is the hash" do
-          expect(outcome).to be_success
-          expect(result).to eq(hash)
-        end
-      end
-
-      context "when hash has symbolizable keys" do
-        let(:hash) { { "foo" => "bar" } }
-
-        it "is the hash with symbolized keys" do
-          expect(outcome).to be_success
-          expect(result).to eq(foo: "bar")
-        end
-      end
-
-      context "when hash has non-symbolizable keys" do
-        let(:hash) { { 10 => "bar" } }
-
-        it "is the hash" do
-          expect(outcome).to_not be_success
-          expect(errors.first.symbol).to eq(:cannot_cast)
-        end
-      end
-    end
-
-    describe "#extends_directly?" do
-      context "when a symbol" do
-        it "is true for its parent symbol" do
-          expect(type.extends_directly?(:attributes)).to be(true)
-        end
-      end
-    end
-  end
-
-  describe "#primitive?" do
-    subject { type.primitive? }
-
-    let(:type) { Foobara::Domain.current.foobara_type_from_declaration(type_declaration) }
-
-    context "when primitive" do
-      let(:type_declaration) { :integer }
-
-      it { is_expected.to be true }
-    end
-
-    context "when derived" do
-      let(:type_declaration) do
-        { type: :integer, description: "an integer!" }
-      end
-
-      it { is_expected.to be false }
-    end
-  end
-
-  describe "#derived?" do
-    subject { type.derived? }
-
-    let(:type) { Foobara::Domain.current.foobara_type_from_declaration(type_declaration) }
-
-    context "when primitive" do
-      let(:type_declaration) { :integer }
-
-      it { is_expected.to be false }
-    end
-
-    context "when derived" do
-      let(:type_declaration) do
-        { type: :integer, description: "an integer!" }
-      end
-
-      it { is_expected.to be true }
-    end
-  end
-end

data/projects/typesystem/spec/value/caster_spec.rb

@@ -1,23 +0,0 @@
-RSpec.describe Foobara::Value::Caster do
-  let(:caster) { described_class.instance }
-
-  describe ".create" do
-    let(:caster) do
-      described_class.create(
-        cast: ->(_whatever) { 1000 },
-        name: "Always1000",
-        applies_message: "be anything"
-      )
-    end
-
-    after do
-      described_class.send(:remove_const, :Always1000)
-    end
-
-    it "creates caster instance with desired behavior" do
-      expect(caster.transform(5)).to eq(1000)
-      expect(caster.name).to eq("Foobara::Value::Caster::Always1000")
-      expect(caster.applies_message).to eq("be anything")
-    end
-  end
-end

data/projects/typesystem/spec/value/processor/runner_spec.rb

@@ -1,34 +0,0 @@
-RSpec.describe Foobara::Value::Processor::Runner do
-  let(:processor_class) {
-    stub_class :Doubler, Foobara::Value::Transformer do
-      attr_accessor :calls
-
-      def initialize(...)
-        super
-        self.calls = 0
-      end
-
-      def transform(value)
-        self.calls += 1
-        value * 2
-      end
-    end.tap do
-      stub_class("Doubler::Error", Foobara::Value::DataError)
-    end
-  }
-
-  let(:processor) { processor_class.instance }
-
-  let(:runner) { processor.runner(value) }
-  let(:value) { 5 }
-
-  describe "calling a runner method twice" do
-    it "memoizes" do
-      expect(processor.calls).to eq(0)
-      expect(runner.transform).to eq(10)
-      expect(processor.calls).to eq(1)
-      expect(runner.transform).to eq(10)
-      expect(processor.calls).to eq(1)
-    end
-  end
-end

data/projects/typesystem/spec/value/processor/selection_spec.rb

@@ -1,71 +0,0 @@
-RSpec.describe Foobara::Value::Processor::Selection do
-  describe "#processor_for!" do
-    subject { selection.processor_for!(value) }
-
-    let(:processor_a) do
-      stub_class "ProcessorA", Foobara::Value::Processor do
-        def applicable?(value)
-          value == :a
-        end
-      end.instance
-    end
-
-    let(:processor_b) do
-      stub_class "ProcessorB", Foobara::Value::Processor do
-        class << self
-          def name
-            "ProcessorB"
-          end
-        end
-        def applicable?(value)
-          value == :b
-        end
-      end.instance
-    end
-
-    let(:processors) { [processor_a, processor_b] }
-
-    let(:selection) do
-      described_class.new(processors:, enforce_unique:)
-    end
-    let(:enforce_unique) { false }
-
-    context "when wanting nil when no processor matches" do
-      let(:error_if_none_applicable) { false }
-      let(:selection) do
-        described_class.new(processors:, enforce_unique:, error_if_none_applicable:)
-      end
-
-      context "when it does not match a processor" do
-        let(:value) { :c }
-
-        it { is_expected.to be_nil }
-      end
-    end
-
-    context "when unique enforced" do
-      let(:enforce_unique) { true }
-
-      context "when it matches multiple processors" do
-        let(:processors) { [processor_a, processor_a] }
-        let(:value) { :a }
-
-        it { is_expected_to_raise(described_class::MoreThanOneApplicableProcessorError) }
-      end
-    end
-
-    context "when unique not enforced" do
-      context "when it matches a processor" do
-        let(:value) { :a }
-
-        it { is_expected.to be(processor_a) }
-      end
-
-      context "when it does not match a processor" do
-        let(:value) { :c }
-
-        it { is_expected_to_raise(described_class::NoApplicableProcessorError) }
-      end
-    end
-  end
-end

data/projects/typesystem/spec/value/processor_spec.rb

@@ -1,76 +0,0 @@
-RSpec.describe Foobara::Value::Processor do
-  let(:processor_class) {
-    stub_class "SomeProcessor", described_class do
-      def process_value(value)
-        if value == 123
-          Foobara::Outcome.error(build_error(symbol: :foo, message: "some error", context: {}))
-        else
-          Foobara::Outcome.success(value)
-        end
-      end
-    end.tap do
-      stub_class "SomeProcessor::Error", Foobara::Value::DataError
-    end
-  }
-
-  let(:processor) { processor_class.new(foo: :bar) }
-
-  describe "#process!" do
-    context "when is an error" do
-      it "raises" do
-        expect {
-          processor.process_value!(123)
-        }.to raise_error(processor_class::Error)
-      end
-    end
-  end
-
-  describe "#process_outcome!" do
-    context "when is an error" do
-      it "raises" do
-        expect {
-          processor.process_outcome!(Foobara::Outcome.success(123))
-        }.to raise_error(processor_class::Error)
-      end
-    end
-
-    context "when is not an error" do
-      it "gives the result" do
-        expect(processor.process_outcome!(Foobara::Outcome.success(10))).to eq(10)
-      end
-    end
-  end
-
-  describe "#dup_processor" do
-    context "when overriding declaration data" do
-      it "dups the processor" do
-        duped_processor = processor.dup_processor(declaration_data: { bar: "baz" })
-
-        expect(processor.declaration_data).to eq(foo: :bar)
-        expect(duped_processor.declaration_data).to eq(bar: "baz")
-      end
-    end
-  end
-
-  describe ".new_with_agnostic_args" do
-    context "when requires declaration data" do
-      let(:processor_class) do
-        stub_class "SomeProcessor", described_class do
-          class << self
-            def requires_declaration_data?
-              true
-            end
-          end
-        end
-      end
-
-      context "when no declaration data provided" do
-        let(:processor) { processor_class.new_with_agnostic_args }
-
-        it "has true as its declaration data" do
-          expect(processor.declaration_data).to be true
-        end
-      end
-    end
-  end
-end

data/projects/typesystem/spec/value/transformer_spec.rb

@@ -1,27 +0,0 @@
-RSpec.describe Foobara::Value::Transformer do
-  let(:transformer) { described_class.instance }
-
-  describe ".create" do
-    let(:transformer) do
-      stub_module "SomeModule"
-
-      described_class.create(
-        transform: ->(_whatever) { 1000 },
-        name: "SomeModule::Always1000",
-        priority: 40
-      )
-    end
-
-    it "creates transformer instance with desired behavior" do
-      expect(transformer.transform(5)).to eq(1000)
-      expect(transformer.name).to eq("SomeModule::Always1000")
-      expect(transformer.priority).to eq(40)
-    end
-  end
-
-  describe "#possible_errors" do
-    it "is always empty" do
-      expect(transformer.possible_errors).to eq([])
-    end
-  end
-end