square.rb 43.0.0.20250618 → 44.0.0.0

data/test/square/internal/multipart/test_form_data.rb

@@ -0,0 +1,311 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "stringio"
+require "json"
+require "test_helper"
+
+class MockFile
+  attr_reader :name, :content, :content_type
+
+  def initialize(name:, content:, content_type: nil)
+    @name = name
+    @content = content
+    @content_type = content_type
+  end
+
+  def read
+    @content
+  end
+end
+
+class MultipartTest < Minitest::Test
+  def test_empty_form_data
+    form_data = Square::Internal::Multipart::FormData.new
+    body = form_data.encode
+
+    assert_equal "", body
+  end
+
+  def test_write_field
+    [
+      {
+        desc: "empty field",
+        field: "empty",
+        value: ""
+      },
+      {
+        desc: "simple field",
+        field: "greeting",
+        value: "hello world"
+      },
+      {
+        desc: "field with content type",
+        field: "message",
+        value: "hello",
+        content_type: "text/plain"
+      }
+    ].each do |test_case|
+      form_data = Square::Internal::Multipart::FormData.new
+      content_type_arg = test_case[:content_type]
+
+      form_data.add(
+        name: test_case[:field],
+        value: test_case[:value],
+        content_type: content_type_arg
+      )
+
+      content_type = form_data.content_type
+      body = form_data.encode
+
+      # Extract the boundary from the content type
+      boundary = content_type.match(/boundary=([^;]+)/)[1]
+
+      # Verify the field was encoded properly
+      assert_includes body, "--#{boundary}"
+      assert_includes body, "Content-Disposition: form-data; name=\"#{test_case[:field]}\""
+
+      assert_includes body, "Content-Type: #{content_type_arg}" if content_type_arg
+
+      assert_includes body, test_case[:value]
+    end
+  end
+
+  def test_write_file_param
+    [
+      {
+        desc: "file param with content type",
+        field: "file",
+        filename: "test.txt",
+        content: "hello world",
+        content_type: "text/plain"
+      },
+      {
+        desc: "file param with override content type",
+        field: "file",
+        filename: "test.txt",
+        content: "hello world",
+        content_type: "text/plain",
+        override_content_type: "application/octet-stream"
+      }
+    ].each do |test_case|
+      form_data = Square::Internal::Multipart::FormData.new
+
+      file_param = Square::FileParam.from_string(
+        content: test_case[:content],
+        filename: test_case[:filename],
+        content_type: test_case[:content_type]
+      )
+
+      form_data.add_part(
+        file_param.to_form_data_part(
+          name: test_case[:field],
+          content_type: test_case[:override_content_type]
+        )
+      )
+
+      content_type = form_data.content_type
+      body = form_data.encode
+
+      # Extract the boundary from the content type
+      boundary = content_type.match(/boundary=([^;]+)/)[1]
+
+      # Verify the file param was encoded properly
+      assert_includes body, "--#{boundary}"
+      assert_includes body,
+                      "Content-Disposition: form-data; name=\"#{test_case[:field]}\"; filename=\"#{test_case[:filename]}\""
+
+      expected_content_type = test_case[:override_content_type] || test_case[:content_type]
+      assert_includes body, "Content-Type: #{expected_content_type}" if expected_content_type
+
+      assert_includes body, test_case[:content]
+    end
+  end
+
+  def test_write_json
+    [
+      {
+        desc: "struct",
+        field: "data",
+        value: { name: "test", value: 123 }
+      },
+      {
+        desc: "map",
+        field: "data",
+        value: { key: "value" }
+      }
+    ].each do |test_case|
+      form_data = Square::Internal::Multipart::FormData.new
+
+      form_data.add(
+        name: test_case[:field],
+        value: test_case[:value].to_json,
+        content_type: "application/json"
+      )
+
+      content_type = form_data.content_type
+      body = form_data.encode
+
+      # Extract the boundary from the content type
+      boundary = content_type.match(/boundary=([^;]+)/)[1]
+
+      # Verify the JSON was encoded properly
+      assert_includes body, "--#{boundary}"
+      assert_includes body, "Content-Disposition: form-data; name=\"#{test_case[:field]}\""
+      assert_includes body, "Content-Type: application/json"
+      assert_includes body, test_case[:value].to_json
+    end
+  end
+
+  def test_complex_form
+    form_data = Square::Internal::Multipart::FormData.new
+
+    # Add multiple fields and files
+    form_data.add(name: "foo", value: "bar")
+    form_data.add(name: "baz", value: "qux")
+
+    part = Square::FileParam.from_string(
+      content: "Hello, world!",
+      filename: "file.txt",
+      content_type: "text/plain"
+    )
+
+    form_data.add_part(part.to_form_data_part(name: "file"))
+    form_data.add(name: "data", value: { key: "value" }.to_json, content_type: "application/json")
+
+    content_type = form_data.content_type
+    body = form_data.encode
+
+    # Extract the boundary from the content type
+    boundary = content_type.match(/boundary=([^;]+)/)[1]
+
+    # Verify all parts are in the body
+    assert_includes body, "--#{boundary}"
+    assert_includes body, "Content-Disposition: form-data; name=\"foo\""
+    assert_includes body, "bar"
+    assert_includes body, "Content-Disposition: form-data; name=\"baz\""
+    assert_includes body, "qux"
+    assert_includes body, "Content-Disposition: form-data; name=\"file\"; filename=\"file.txt\""
+    assert_includes body, "Content-Type: text/plain"
+    assert_includes body, "Hello, world!"
+    assert_includes body, "Content-Disposition: form-data; name=\"data\""
+    assert_includes body, "Content-Type: application/json"
+    assert_includes body, "{\"key\":\"value\"}"
+  end
+
+  def test_file_param_from_filepath
+    # Create a temporary file for testing
+    file_content = "Test file content"
+    temp_file = Tempfile.new(["test", ".txt"])
+    begin
+      temp_file.write(file_content)
+      temp_file.rewind
+
+      file_param = Square::FileParam.from_filepath(
+        filepath: temp_file.path,
+        content_type: "text/plain"
+      )
+
+      # Verify the file param was created properly
+      form_data = Square::Internal::Multipart::FormData.new
+      form_data.add_part(file_param.to_form_data_part(name: "file"))
+
+      content_type = form_data.content_type
+      body = form_data.encode
+
+      # Extract the boundary from the content type
+      boundary = content_type.match(/boundary=([^;]+)/)[1]
+
+      # Verify the file was encoded properly
+      assert_includes body, "--#{boundary}"
+      assert_includes body,
+                      "Content-Disposition: form-data; name=\"file\"; filename=\"#{File.basename(temp_file.path)}\""
+      assert_includes body, "Content-Type: text/plain"
+      assert_includes body, file_content
+    ensure
+      # Close and delete the temporary file
+      temp_file.close
+      temp_file.unlink
+    end
+  end
+
+  def test_file_param_from_string
+    file_content = "Test string content"
+    filename = "string.txt"
+    content_type = "text/plain"
+
+    file_param = Square::FileParam.from_string(
+      content: file_content,
+      filename: filename,
+      content_type: content_type
+    )
+
+    # Verify the file param was created properly
+    form_data = Square::Internal::Multipart::FormData.new
+    form_data.add_part(file_param.to_form_data_part(name: "file"))
+
+    content_type = form_data.content_type
+    body = form_data.encode
+
+    # Extract the boundary from the content type
+    boundary = content_type.match(/boundary=([^;]+)/)[1]
+
+    # Verify the file was encoded properly
+    assert_includes body, "--#{boundary}"
+    assert_includes body, "Content-Disposition: form-data; name=\"file\"; filename=\"#{filename}\""
+    assert_includes body, "Content-Type: text/plain"
+    assert_includes body, file_content
+  end
+
+  def test_encoder_file_reading_in_chunks
+    file_size = 1024 * 100 # 100KB
+    large_content = "x" * file_size
+
+    temp_file = Tempfile.new(["large", ".dat"])
+    begin
+      temp_file.write(large_content)
+      temp_file.rewind
+
+      form_data = Square::Internal::Multipart::FormData.new
+      form_data.add_file(
+        name: "large_file",
+        file: temp_file,
+        content_type: "application/octet-stream"
+      )
+
+      content_type = form_data.content_type
+      body = form_data.encode
+
+      boundary = content_type.match(/boundary=([^;]+)/)[1]
+
+      assert_includes body, "--#{boundary}"
+      assert_includes body,
+                      "Content-Disposition: form-data; name=\"large_file\"; filename=\"#{File.basename(temp_file.path)}\""
+      assert_includes body, "Content-Type: application/octet-stream"
+
+      content_start = body.index("Content-Type: application/octet-stream\r\n\r\n") +
+                      "Content-Type: application/octet-stream\r\n\r\n".length
+
+      content_end = body.index("\r\n--#{boundary}", content_start)
+
+      actual_content = body[content_start...content_end]
+
+      assert_equal file_size, actual_content.length
+
+      # Verify the content is correct (checking first, middle, and last parts).
+      assert_equal "x" * 100, actual_content[0...100]
+      assert_equal "x" * 100, actual_content[((file_size / 2) - 50)...((file_size / 2) + 50)]
+      assert_equal "x" * 100, actual_content[(file_size - 100)...file_size]
+    ensure
+      # Close and delete the temporary file.
+      temp_file.close
+      temp_file.unlink
+    end
+  end
+
+  def test_error_handling_for_missing_file
+    assert_raises(StandardError) do
+      Square::FileParam.from_filepath(filepath: "nonexistent_file.txt")
+    end
+  end
+end

data/test/square/internal/types/test_array.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe Square::Internal::Types::Array do
+  module TestArray
+    StringArray = Square::Internal::Types::Array[String]
+  end
+
+  describe "#initialize" do
+    it "sets the type" do
+      assert_equal String, TestArray::StringArray.type
+    end
+  end
+
+  describe "#coerce" do
+    it "does not perform coercion if not an array" do
+      assert_equal 1, TestArray::StringArray.coerce(1)
+    end
+
+    it "raises an error if not an array and strictness is on" do
+      assert_raises Square::Internal::Errors::TypeError do
+        TestArray::StringArray.coerce(1, strict: true)
+      end
+    end
+
+    it "coerces the elements" do
+      assert_equal %w[foobar 1 true], TestArray::StringArray.coerce(["foobar", 1, true])
+    end
+
+    it "raises an error if element of array is not coercable and strictness is on" do
+      assert_raises Square::Internal::Errors::TypeError do
+        TestArray::StringArray.coerce([Object.new], strict: true)
+      end
+    end
+  end
+end

data/test/square/internal/types/test_boolean.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe Square::Internal::Types::Boolean do
+  describe ".coerce" do
+    it "coerces true/false" do
+      assert Square::Internal::Types::Boolean.coerce(true)
+      refute Square::Internal::Types::Boolean.coerce(false)
+    end
+
+    it "coerces an Integer" do
+      assert Square::Internal::Types::Boolean.coerce(1)
+      refute Square::Internal::Types::Boolean.coerce(0)
+    end
+
+    it "coerces a String" do
+      assert Square::Internal::Types::Boolean.coerce("1")
+      assert Square::Internal::Types::Boolean.coerce("true")
+      refute Square::Internal::Types::Boolean.coerce("0")
+    end
+
+    it "passes through other values with strictness off" do
+      obj = Object.new
+
+      assert_equal obj, Square::Internal::Types::Boolean.coerce(obj)
+    end
+
+    it "raises an error with other values with strictness on" do
+      assert_raises Square::Internal::Errors::TypeError do
+        Square::Internal::Types::Boolean.coerce(Object.new, strict: true)
+      end
+    end
+  end
+end

data/test/square/internal/types/test_enum.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe Square::Internal::Types::Enum do
+  module EnumTest
+    module ExampleEnum
+      extend Square::Internal::Types::Enum
+
+      FOO = :foo
+      BAR = :bar
+
+      finalize!
+    end
+  end
+
+  describe "#values" do
+    it "defines values" do
+      assert_equal %i[foo bar].sort, EnumTest::ExampleEnum.values.sort
+    end
+  end
+
+  describe "#coerce" do
+    it "coerces an existing member" do
+      assert_equal :foo, EnumTest::ExampleEnum.coerce(:foo)
+    end
+
+    it "coerces a string version of a member" do
+      assert_equal :foo, EnumTest::ExampleEnum.coerce("foo")
+    end
+
+    it "returns the value if not a member with strictness off" do
+      assert_equal 1, EnumTest::ExampleEnum.coerce(1)
+    end
+
+    it "raises an error if value is not a member with strictness on" do
+      assert_raises Square::Internal::Errors::TypeError do
+        EnumTest::ExampleEnum.coerce(1, strict: true)
+      end
+    end
+  end
+end

data/test/square/internal/types/test_hash.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe Square::Internal::Types::Hash do
+  module TestHash
+    SymbolStringHash = Square::Internal::Types::Hash[Symbol, String]
+  end
+
+  describe ".[]" do
+    it "defines the key and value type" do
+      assert_equal Symbol, TestHash::SymbolStringHash.key_type
+      assert_equal String, TestHash::SymbolStringHash.value_type
+    end
+  end
+
+  describe "#coerce" do
+    it "coerces the keys" do
+      assert_equal %i[foo bar], TestHash::SymbolStringHash.coerce({ "foo" => "1", :bar => "2" }).keys
+    end
+
+    it "coerces the values" do
+      assert_equal %w[foo 1], TestHash::SymbolStringHash.coerce({ foo: :foo, bar: 1 }).values
+    end
+
+    it "passes through other values with strictness off" do
+      obj = Object.new
+
+      assert_equal obj, TestHash::SymbolStringHash.coerce(obj)
+    end
+
+    it "raises an error with other values with strictness on" do
+      assert_raises Square::Internal::Errors::TypeError do
+        TestHash::SymbolStringHash.coerce(Object.new, strict: true)
+      end
+    end
+
+    it "raises an error with non-coercable key types with strictness on" do
+      assert_raises Square::Internal::Errors::TypeError do
+        TestHash::SymbolStringHash.coerce({ Object.new => 1 }, strict: true)
+      end
+    end
+
+    it "raises an error with non-coercable value types with strictness on" do
+      assert_raises Square::Internal::Errors::TypeError do
+        TestHash::SymbolStringHash.coerce({ "foobar" => Object.new }, strict: true)
+      end
+    end
+  end
+end

data/test/square/internal/types/test_model.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe Square::Internal::Types::Model do
+  module StringInteger
+    extend Square::Internal::Types::Union
+
+    member String
+    member Integer
+  end
+
+  class ExampleModel < Square::Internal::Types::Model
+    field :name, String
+    field :rating, StringInteger, optional: true
+    field :year, Integer, optional: true, nullable: true, api_name: "yearOfRelease"
+  end
+
+  class ExampleModelInheritance < ExampleModel
+    field :director, String
+  end
+
+  class ExampleWithDefaults < ExampleModel
+    field :type, String, default: "example"
+  end
+
+  class ExampleChild < Square::Internal::Types::Model
+    field :value, String
+  end
+
+  class ExampleParent < Square::Internal::Types::Model
+    field :child, ExampleChild
+  end
+
+  describe ".field" do
+    before do
+      @example = ExampleModel.new(name: "Inception", rating: 4)
+    end
+
+    it "defines fields on model" do
+      assert_equal %i[name rating year], ExampleModel.fields.keys
+    end
+
+    it "defines fields from parent models" do
+      assert_equal %i[name rating year director], ExampleModelInheritance.fields.keys
+    end
+
+    it "sets the field's type" do
+      assert_equal String, ExampleModel.fields[:name].type
+      assert_equal StringInteger, ExampleModel.fields[:rating].type
+    end
+
+    it "sets the `default` option" do
+      assert_equal "example", ExampleWithDefaults.fields[:type].default
+    end
+
+    it "defines the accessors" do
+      assert_respond_to @example, :name
+      assert_respond_to @example, :rating
+    end
+
+    it "defines the setters" do
+      assert_respond_to @example, :name=
+      assert_respond_to @example, :rating=
+    end
+  end
+
+  describe "#initialize" do
+    it "sets the data" do
+      example = ExampleModel.new(name: "Inception", rating: 4)
+
+      assert_equal "Inception", example.name
+      assert_equal 4, example.rating
+    end
+
+    it "allows extra fields to be set" do
+      example = ExampleModel.new(name: "Inception", rating: 4, director: "Christopher Nolan")
+
+      assert_equal "Christopher Nolan", example.director
+    end
+
+    it "sets the defaults where applicable" do
+      example_using_defaults = ExampleWithDefaults.new
+
+      assert_equal "example", example_using_defaults.type
+
+      example_without_defaults = ExampleWithDefaults.new(type: "not example")
+
+      assert_equal "not example", example_without_defaults.type
+    end
+
+    it "coerces child models" do
+      parent = ExampleParent.new(child: { value: "foobar" })
+
+      assert_kind_of ExampleChild, parent.child
+    end
+
+    it "uses the api_name to pull the value" do
+      example = ExampleModel.new({ name: "Inception", yearOfRelease: 2014 })
+
+      assert_equal 2014, example.year
+      refute_respond_to example, :yearOfRelease
+    end
+  end
+end

data/test/square/internal/types/test_union.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "test_helper"
+describe Square::Internal::Types::Union do
+  class Rectangle < Square::Internal::Types::Model
+    literal :type, "square"
+
+    field :area, Float
+  end
+
+  class Circle < Square::Internal::Types::Model
+    literal :type, "circle"
+
+    field :area, Float
+  end
+
+  module Shape
+    extend Square::Internal::Types::Union
+
+    discriminant :type
+
+    member -> { Rectangle }, key: "rect"
+    member -> { Circle }, key: "circle"
+  end
+
+  module StringOrInteger
+    extend Square::Internal::Types::Union
+
+    member String
+    member Integer
+  end
+
+  describe "#coerce" do
+    it "coerces hashes into member models with discriminated unions" do
+      circle = Shape.coerce({ type: "circle", area: 4.0 })
+
+      assert_instance_of Circle, circle
+    end
+  end
+
+  describe "#member" do
+    it "defines Model members" do
+      assert Shape.member?(Rectangle)
+      assert Shape.member?(Circle)
+    end
+
+    it "defines other members" do
+      assert StringOrInteger.member?(String)
+      assert StringOrInteger.member?(Integer)
+    end
+  end
+end