square.rb 44.2.0.20251016 → 45.0.1.20260122

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

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

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

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

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

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

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

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