foobara 0.3.0 → 0.4.1

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

@@ -0,0 +1,210 @@
+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

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,252 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,65 @@
+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

@@ -0,0 +1,36 @@
+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