foobara 0.5.10 → 0.6.2

data/projects/typesystem/spec/type_declarations/sensitive_type_removers_spec.rb

@@ -1,210 +0,0 @@
-RSpec.describe Foobara::TypeDeclarations do
-  after { Foobara.reset_alls }
-
-  describe ".remove_sensitive_types" do
-    let(:strict_type_declaration) do
-      type.declaration_data
-    end
-
-    let(:type_declaration_without_sensitive_types) do
-      described_class.remove_sensitive_types(strict_type_declaration)
-    end
-
-    context "when attributes" do
-      let(:type) do
-        Foobara::Domain.current.foobara_type_from_declaration do
-          foo :string, :required, default: "foo"
-          bar :string, :required, default: "bar"
-          bar2 :string, :sensitive, :required, default: "bar2"
-          baz :string
-        end
-      end
-
-      it "strips out the sensitive attributes" do
-        expect(type_declaration_without_sensitive_types).to eq(
-          type: :attributes,
-          element_type_declarations: {
-            baz: :string,
-            bar: :string,
-            foo: :string
-          },
-          required: [:bar, :foo],
-          defaults: { foo: "foo", bar: "bar" }
-        )
-      end
-
-      context "when nested sensitive stuff" do
-        let(:type) do
-          Foobara::Domain.current.foobara_type_from_declaration do
-            foo :string, :required, default: "foo"
-            bar :string, :sensitive, :required, default: "bar"
-            baz :string
-            nested do
-              foo :string, :required, default: "foo"
-              bar :string, :sensitive, :required, default: "bar"
-              baz :string
-            end
-            baz2 :array do
-              baz3 :string, :sensitive
-              foo :string
-            end
-          end
-        end
-
-        it "strips out the sensitive attributes all the way down" do
-          expect(type_declaration_without_sensitive_types).to eq(
-            type: :attributes,
-            element_type_declarations: {
-              baz: :string,
-              foo: :string,
-              nested: {
-                type: :attributes,
-                element_type_declarations: {
-                  baz: :string,
-                  foo: :string
-                },
-                required: [:foo],
-                defaults: { foo: "foo" }
-              },
-              baz2: {
-                type: :array,
-                element_type_declaration: {
-                  type: :attributes,
-                  element_type_declarations: { foo: :string }
-                }
-              }
-            },
-            required: [:foo],
-            defaults: { foo: "foo" }
-          )
-        end
-      end
-
-      context "when no sensitive attributes" do
-        let(:type) do
-          Foobara::Domain.current.foobara_type_from_declaration do
-            foo :string, :required, default: "foo"
-            bar :string, :required, default: "bar"
-            baz :string
-          end
-        end
-
-        it "gives the type declaration unchanged" do
-          expect(type_declaration_without_sensitive_types).to eq(
-            type: :attributes,
-            element_type_declarations: {
-              baz: :string,
-              bar: :string,
-              foo: :string
-            },
-            required: [:bar, :foo],
-            defaults: { foo: "foo", bar: "bar" }
-          )
-        end
-      end
-
-      context "when there's no direct sensitive attributes but an attribute contains a sensitive attribute" do
-        let(:type) do
-          Foobara::Domain.current.foobara_type_from_declaration do
-            foo do
-              foo :string
-              baz :string, :sensitive
-            end
-          end
-        end
-
-        it "strips out the nested sensitive attribute" do
-          expect(type_declaration_without_sensitive_types[:element_type_declarations]).to eq(
-            foo: {
-              type: :attributes,
-              element_type_declarations: {
-                foo: :string
-              }
-            }
-          )
-        end
-      end
-    end
-
-    context "when array" do
-      let(:type) do
-        Foobara::Domain.current.foobara_type_from_declaration(
-          [
-            { type: :attributes,
-              element_type_declarations:
-               { foo: { type: :string },
-                 bar: {  type: :string },
-                 bar2: { sensitive: true, type: :string },
-                 baz: { type: :string },
-                 nested:
-                  { type: :attributes,
-                    element_type_declarations: {
-                      foo: { type: :string },
-                      bar: { type: :string },
-                      bar2: {
-                        sensitive: true, type: :string
-                      }, baz: { type: :string }
-                    },
-                    required: [:foo, :bar],
-                    defaults: { foo: "foo", bar: "bar" } },
-                 baz2: {
-                   type: :array,
-                   element_type_declaration: {
-                     type: :attributes,
-                     element_type_declarations: {
-                       baz3: { sensitive: true, type: :string },
-                       foo: { type: :string }
-                     }
-                   }
-                 } },
-              required: [:foo, :bar],
-              defaults: { foo: "foo", bar: "bar" } }
-
-          ]
-        )
-      end
-
-      it "strips out the sensitive attributes all the way down" do
-        expect(type_declaration_without_sensitive_types).to eq(
-          type: :array,
-          element_type_declaration: {
-            type: :attributes,
-            element_type_declarations: {
-              foo: :string,
-              bar: :string,
-              baz: :string,
-              nested: {
-                type: :attributes,
-                element_type_declarations: {
-                  foo: :string,
-                  bar: :string,
-                  baz: :string
-                },
-                required: [:bar, :foo], defaults: { foo: "foo", bar: "bar" }
-              },
-              baz2: {
-                type: :array,
-                element_type_declaration: {
-                  type: :attributes,
-                  element_type_declarations: { foo: :string }
-                }
-              }
-            },
-            required: [:bar, :foo],
-            defaults: { foo: "foo", bar: "bar" }
-          }
-        )
-      end
-    end
-
-    context "when non-sensitive built-in type" do
-      let(:type) do
-        Foobara::BuiltinTypes[:integer]
-      end
-
-      it "returns the declaration unmodified" do
-        expect(type_declaration_without_sensitive_types).to eq(strict_type_declaration)
-      end
-    end
-  end
-end

data/projects/typesystem/spec/type_declarations/type_builder_spec.rb

@@ -1,47 +0,0 @@
-RSpec.describe Foobara::TypeDeclarations::TypeBuilder do
-  after do
-    Foobara.reset_alls
-  end
-
-  let(:type_builder) do
-    Foobara::GlobalDomain.foobara_type_builder
-  end
-
-  describe "#type_for_declaration" do
-    context "when declaring an array of attributes" do
-      context "when via :array and a block" do
-        it "builds the expected type" do
-          type = type_builder.type_for_declaration(:array) do
-            foo :string, :required
-          end
-
-          expect(type.declaration_data).to eq(
-            type: :array,
-            element_type_declaration: {
-              type: :attributes,
-              element_type_declarations: { foo: :string },
-              required: [:foo]
-            }
-          )
-        end
-      end
-
-      context "when via array literal with a lambda" do
-        it "builds the expected type" do
-          type = type_builder.type_for_declaration([-> {
-            foo :string, :required
-          }])
-
-          expect(type.declaration_data).to eq(
-            type: :array,
-            element_type_declaration: {
-              type: :attributes,
-              element_type_declarations: { foo: :string },
-              required: [:foo]
-            }
-          )
-        end
-      end
-    end
-  end
-end

data/projects/typesystem/spec/type_declarations/type_declaration_spec.rb

@@ -1,252 +0,0 @@
-RSpec.describe Foobara::TypeDeclaration do
-  let(:declaration_data) do
-    {
-      foo: :integer,
-      bar: :integer
-    }
-  end
-
-  let(:type_declaration) do
-    described_class.new(declaration_data)
-  end
-
-  describe "#delete" do
-    it "deletes the expected attribute and results in a duped declaration" do
-      expect(type_declaration.key?(:foo)).to be true
-      expect(type_declaration).to_not be_duped
-
-      type_declaration.delete(:foo)
-
-      expect(type_declaration.key?(:foo)).to be false
-      expect(type_declaration).to be_duped
-    end
-
-    context "when strict" do
-      let(:declaration_data) do
-        {
-          type: :attributes,
-          element_type_declarations: {
-            foo: :integer,
-            bar: :integer
-          },
-          required: [:foo, :bar]
-        }
-      end
-      let(:type_declaration) do
-        described_class.new(declaration_data, true)
-      end
-
-      context "when removing :type key" do
-        it "clears the absolutified flag" do
-          expect {
-            type_declaration.delete(:type)
-
-            expect(type_declaration.declaration_data).to eq(
-              element_type_declarations: {
-                foo: :integer,
-                bar: :integer
-              },
-              required: [:foo, :bar]
-            )
-          }.to change(type_declaration, :absolutified?).from(true).to(false)
-        end
-      end
-    end
-
-    context "when absolutified" do
-      let(:declaration_data) do
-        {
-          type: :attributes,
-          element_type_declarations: {
-            foo: :integer,
-            bar: :integer
-          },
-          required: [:foo, :bar]
-        }
-      end
-      let(:type_declaration) do
-        super().tap do |declaration|
-          declaration.is_strict = true
-        end
-      end
-
-      it "removes the strict flag" do
-        expect {
-          type_declaration.delete(:required)
-        }.to change(type_declaration, :strict?).from(true).to(false)
-      end
-
-      context "when removing :type key" do
-        it "clears the absolutified flag" do
-          expect {
-            type_declaration.delete(:type)
-
-            expect(type_declaration.declaration_data).to eq(
-              element_type_declarations: {
-                foo: :integer,
-                bar: :integer
-              },
-              required: [:foo, :bar]
-            )
-          }.to change(type_declaration, :absolutified?).from(true).to(false)
-        end
-      end
-    end
-  end
-
-  describe "#except" do
-    context "when strict" do
-      let(:declaration_data) do
-        {
-          type: :attributes,
-          element_type_declarations: {
-            foo: :integer,
-            bar: :integer
-          },
-          required: [:foo, :bar]
-        }
-      end
-      let(:type_declaration) do
-        Foobara::TypeDeclarations.strict do
-          super()
-        end
-      end
-
-      it "removes the strict flag" do
-        declaration = type_declaration
-
-        expect {
-          declaration = declaration.except(:required)
-
-          expect(declaration.declaration_data).to eq(
-            type: :attributes,
-            element_type_declarations: {
-              foo: :integer,
-              bar: :integer
-            }
-          )
-          # Hmmm rubocop complains about !! use... TODO: disable that?
-        }.to change { declaration.strict? == true }.from(true).to(false)
-      end
-    end
-
-    context "when strict_stringified" do
-      let(:declaration_data) do
-        {
-          "type" => "attributes",
-          "element_type_declarations" => {
-            "foo" => "integer",
-            "bar" => "integer"
-          },
-          "required" => ["foo", "bar"]
-        }
-      end
-
-      let(:type_declaration) do
-        Foobara::TypeDeclarations.strict_stringified do
-          super()
-        end
-      end
-
-      it "removes the element" do
-        declaration = type_declaration.except(:required)
-
-        expect(declaration.declaration_data).to eq(
-          type: :attributes,
-          element_type_declarations: {
-            "foo" => "integer",
-            "bar" => "integer"
-          }
-        )
-      end
-    end
-  end
-
-  describe "#clone" do
-    context "when strict with a type" do
-      let(:type_declaration) do
-        super().tap do |declaration|
-          declaration.is_strict = true
-          declaration.type = Foobara::Domain.current.foobara_type_from_declaration(declaration_data)
-        end
-      end
-
-      it "preserves the strict flag and type" do
-        clone = type_declaration.clone
-
-        expect(clone.type).to be_a(Foobara::Type)
-        expect(clone).to be_strict
-      end
-    end
-  end
-
-  describe "#assign" do
-    context "when strict" do
-      let(:declaration_data) do
-        {
-          type: :attributes,
-          element_type_declarations: {
-            foo: :integer,
-            bar: :integer
-          },
-          required: [:foo, :bar]
-        }
-      end
-      let(:type_declaration) do
-        super().tap do |declaration|
-          declaration.is_strict = true
-        end
-      end
-
-      it "copies everything over" do
-        clone = described_class.new(foo: :bar)
-
-        clone.assign(type_declaration)
-
-        expect(clone.declaration_data).to eq(
-          type: :attributes,
-          element_type_declarations: {
-            foo: :integer,
-            bar: :integer
-          },
-          required: [:foo, :bar]
-        )
-        expect(clone).to be_absolutified
-      end
-    end
-  end
-
-  describe "#initialize" do
-    context "when a type symbol" do
-      let(:declaration_data) { :integer }
-
-      it "sets the type and various flags" do
-        expect(type_declaration.type).to be(Foobara::BuiltinTypes[:integer])
-
-        expect(type_declaration.declaration_data).to eq(:integer)
-
-        expect(type_declaration).to be_strict
-        expect(type_declaration).to be_absolutified
-        expect(type_declaration).to be_duped
-        expect(type_declaration).to be_deep_duped
-      end
-
-      context "when absolutified" do
-        let(:type_declaration) do
-          described_class.new(declaration_data, true)
-        end
-
-        it "sets the type and various flags" do
-          expect(type_declaration.type).to be(Foobara::BuiltinTypes[:integer])
-
-          expect(type_declaration.declaration_data).to eq(:integer)
-
-          expect(type_declaration).to be_strict
-          expect(type_declaration).to be_absolutified
-          expect(type_declaration).to be_duped
-          expect(type_declaration).to be_deep_duped
-        end
-      end
-    end
-  end
-end

data/projects/typesystem/spec/type_declarations/type_declarations_spec.rb

@@ -1,11 +0,0 @@
-RSpec.describe Foobara::TypeDeclarations do
-  describe ".strict" do
-    it "puts it in strict mode" do
-      expect(described_class.strict?).to be(false)
-      described_class.strict do
-        expect(described_class.strict?).to be(true)
-      end
-      expect(described_class.strict?).to be(false)
-    end
-  end
-end

data/projects/typesystem/spec/type_declarations/typed_transformer_spec.rb

@@ -1,65 +0,0 @@
-RSpec.describe Foobara::TypeDeclarations::TypedTransformer do
-  after { Foobara.reset_alls }
-
-  describe ".to/.to_type .from/.from_type" do
-    context "when .type_declaration is a type" do
-      let(:transformer_class) do
-        stub_class :SomeTransformer, described_class do
-          from :integer
-          to :string
-
-          def transform(int)
-            int.to_s
-          end
-        end
-      end
-
-      it "results in typed transformer instances with those types" do
-        transformer = transformer_class.instance
-
-        expect(transformer_class.from_type).to eq(Foobara::BuiltinTypes[:integer])
-        expect(transformer_class.to_type).to eq(Foobara::BuiltinTypes[:string])
-
-        expect(transformer.from_type).to eq(Foobara::BuiltinTypes[:integer])
-        expect(transformer.to_type).to eq(Foobara::BuiltinTypes[:string])
-
-        expect(transformer.process_value!(5)).to eq("5")
-      end
-    end
-  end
-
-  describe "#from_type_declaration" do
-    let(:transformer_class) do
-      stub_class "Dearrayify", described_class do
-        def from_type_declaration
-          [to_type.declaration_data]
-        end
-      end
-    end
-
-    it "gives a way to define the define the from type in terms of the to type" do
-      transformer = transformer_class.new(to: :integer)
-
-      expect(transformer.from_type.declaration_data).to eq(
-        Foobara::Domain.current.foobara_type_from_declaration([:integer]).declaration_data
-      )
-    end
-
-    context "with no types" do
-      let(:transformer_class) do
-        stub_class :SomeTransformer, described_class do
-          def transform(int)
-            int.to_s
-          end
-        end
-      end
-
-      it "pointless, but it can still translate" do
-        expect(transformer_class.from_type).to be_nil
-        expect(transformer_class.to_type).to be_nil
-
-        expect(transformer_class.instance.process_value!(5)).to eq("5")
-      end
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-RSpec.describe Foobara::Types do
-  after { Foobara.reset_alls }
-
-  describe "#foobara_manifest" do
-    context "when type is registered" do
-      before do
-        Foobara::GlobalDomain.foobara_register_type(:some_type, type)
-      end
-
-      context "when type is sensitive" do
-        let(:type) do
-          Foobara::GlobalDomain.foobara_type_from_declaration(:string, :sensitive)
-        end
-
-        it "includes a sensitive flag" do
-          expect(type).to be_sensitive
-          expect(type.foobara_manifest[:sensitive]).to be true
-          # TODO: come up with a better name for sensitive_exposed and/or sensitive
-          expect(type.foobara_manifest.key?(:sensitive_exposed)).to be false
-        end
-      end
-
-      context "when it is sensitive_exposed" do
-        let(:type) do
-          Foobara::GlobalDomain.foobara_type_from_declaration(:string, :sensitive_exposed)
-        end
-
-        it "includes a sensitive_exposed flag" do
-          expect(type).to be_sensitive_exposed
-          expect(type.foobara_manifest.key?(:sensitive)).to be false
-          expect(type.foobara_manifest[:sensitive_exposed]).to be true
-        end
-      end
-    end
-  end
-end