fixturama 0.1.0 → 0.5.0

data/lib/fixturama/stubs/const.rb

@@ -1,43 +0,0 @@
-module Fixturama
-  #
-  # Definition for stubbing a constant
-  #
-  class Stubs::Const
-    attr_reader :const, :value
-
-    #
-    # Human-readable representation of the chain
-    # @return [String]
-    #
-    def to_s
-      const.to_s
-    end
-    alias to_str to_s
-    alias key to_s
-
-    #
-    # Overload the definition for the constant
-    # @option [Object] value
-    # @return [self]
-    #
-    def update!(value:, **)
-      @value = value
-      self
-    end
-
-    #
-    # Apply the stub to RSpec example
-    # @return [self]
-    #
-    def apply!(example)
-      example.send(:stub_const, const, value)
-      self
-    end
-
-    private
-
-    def initialize(const:, **)
-      @const = const.to_s
-    end
-  end
-end

data/lib/fixturama/stubs/request.rb

@@ -1,98 +0,0 @@
-#
-# Stubbed request
-#
-class Fixturama::Stubs::Request
-  require_relative "request/response"
-  require_relative "request/responses"
-
-  def to_s
-    "#{http_method.upcase} #{uri.to_s == "" ? "*" : uri}"
-  end
-  alias to_str to_s
-
-  # every stub is unique
-  alias key hash
-  def update!(_); end
-
-  def apply!(example)
-    stub = example.stub_request(http_method, uri)
-    stub = stub.with(request) if request.any?
-    stub.to_return { |_| responses.next }
-  end
-
-  private
-
-  attr_reader :options
-
-  def initialize(options)
-    @options = options
-    with_error { @options = Hash(options).symbolize_keys }
-  end
-
-  HTTP_METHODS = %i[get post put patch delete head options any].freeze
-
-  def http_method
-    value = with_error("method") { options[:method]&.to_sym&.downcase } || :any
-    return value if HTTP_METHODS.include?(value)
-
-    raise ArgumentError, "Invalid HTTP method #{value} in #{@optons}"
-  end
-
-  def uri
-    with_error("uri") { maybe_regexp(options[:uri] || options[:url]) }
-  end
-
-  def headers
-    with_error("headers") do
-      Hash(options[:headers]).transform_keys(&:to_s) if options.key?(:headers)
-    end
-  end
-
-  def query
-    with_error("query") do
-      Hash(options[:query]).transform_keys(&:to_s) if options.key?(:query)
-    end
-  end
-
-  def body
-    with_error("body") do
-      case options[:body]
-      when NilClass then nil
-      when Hash then options[:body]
-      else maybe_regexp(options[:body])
-      end
-    end
-  end
-
-  def basic_auth
-    with_error("basic auth") do
-      value = options[:auth] || options[:basic_auth]
-      Hash(value).transform_keys(&:to_s).values_at("user", "pass") if value
-    end
-  end
-
-  def request
-    @request ||= {
-      headers: headers,
-      body: body,
-      query: query,
-      basic_auth: basic_auth
-    }.select { |_, val| val }
-  end
-
-  def responses
-    @responses ||= Responses.new(options[:response] || options[:responses])
-  end
-
-  def with_error(part = nil)
-    yield
-  rescue RuntimeError
-    message = ["Cannot extract a request", part, "from #{options}"].join(" ")
-    raise ArgumentError, message, __FILE__, __LINE__ - 1
-  end
-
-  def maybe_regexp(str)
-    str = str.to_s
-    str[%r{\A/.*/\z}] ? Regexp.new(str[1..-2]) : str
-  end
-end

data/lib/fixturama/stubs/request/response.rb

@@ -1,43 +0,0 @@
-class Fixturama::Stubs::Request
-  class Response
-    def to_h
-      { status:  status, body: body, headers: headers }.select { |_, val| val }
-    end
-
-    private
-
-    def initialize(options)
-      @options = options
-      @options = with_error { Hash(options).transform_keys(&:to_sym) }
-    end
-
-    attr_reader :options
-
-    def status
-      with_error("status") { options[:status]&.to_i } || 200
-    end
-
-    def body
-      with_error("body") do
-        case options[:body]
-        when NilClass then nil
-        when Hash then JSON.dump(options[:body])
-        else options[:body].to_s
-        end
-      end
-    end
-
-    def headers
-      with_error("headers") do
-        Hash(options[:headers]).map { |k, v| [k.to_s, v.to_s] }.to_h
-      end
-    end
-
-    def with_error(part = nil)
-      yield
-    rescue RuntimeError
-      text = ["Cannot extract a response", part, "from #{options}"].join(" ")
-      raise ArgumentError, text, __FILE__, __LINE__ - 1
-    end
-  end
-end

data/lib/fixturama/stubs/request/responses.rb

@@ -1,20 +0,0 @@
-class Fixturama::Stubs::Request
-  class Responses
-    def next
-      list.count > @count ? list[@count].tap { @count += 1 } : list.last
-    end
-
-    private
-
-    def initialize(list)
-      @count = 0
-      list ||= [{ status: 200 }]
-      @list = case list
-              when Array then list.map { |item| Response.new(item).to_h }
-              else [Response.new(list).to_h]
-              end
-    end
-
-    attr_reader :list
-  end
-end

data/lib/fixturama/utils.rb

@@ -1,39 +0,0 @@
-module Fixturama
-  module Utils
-    module_function
-
-    def symbolize(item)
-      item.to_s.to_sym
-    end
-
-    def symbolize_hash(data)
-      Hash(data).transform_keys { |key| symbolize(key)}
-    end
-
-    def symbolize_array(data)
-      Array(data).map { |item| symbolize(item) }
-    end
-
-    def constantize(item)
-      Kernel.const_get(item.to_s)
-    end
-
-    def clone(item)
-      item.respond_to?(:dup) ? item.dup : item
-    end
-
-    def array(list)
-      case list
-      when NilClass then []
-      when Array    then list
-      else [list]
-      end
-    end
-
-    def matched_hash_args?(actual, expected)
-      return unless actual.is_a?(Hash) && expected.is_a?(Hash)
-
-      expected.all? { |key, val| actual[key] == val }
-    end
-  end
-end

data/spec/fixturama/load_fixture/_spec.rb

@@ -1,53 +0,0 @@
-RSpec.describe "load_fixture" do
-  let(:expected) { { "foo" => { "bar" => 42 } } }
-
-  context "YAML" do
-    subject { load_fixture("#{__dir__}/data.yaml", id: 42) }
-
-    it { is_expected.to eq expected }
-  end
-
-  context "YML" do
-    subject { load_fixture("#{__dir__}/data.yml", id: 42) }
-
-    it { is_expected.to eq expected }
-  end
-
-  context "YAML with ruby object" do
-    subject { load_fixture("#{__dir__}/data.yaml", id: foobar) }
-
-    before { class Test::Foobar; end }
-
-    let(:foobar)   { Test::Foobar.new }
-    let(:expected) { { "foo" => { "bar" => foobar } } }
-
-    it { is_expected.to eq expected }
-  end
-
-  context "JSON" do
-    subject { load_fixture("#{__dir__}/data.json", id: 42) }
-
-    it { is_expected.to eq expected }
-  end
-
-  context "JSON with ruby object" do
-    subject { load_fixture("#{__dir__}/data.json", id: foobar) }
-
-    before { class Test::Foobar; end }
-
-    let(:foobar)   { Test::Foobar.new }
-    let(:expected) { { "foo" => { "bar" => foobar } } }
-
-    it { is_expected.to eq expected }
-  end
-
-  context "with RSpec argument matchers" do
-    subject { load_fixture("#{__dir__}/data.yaml", id: kind_of(Numeric)) }
-
-    it "loads the matcher", aggregate_failures: true do
-      expect("foo" => { "bar" => 42 }).to include subject
-      expect("foo" => { "bar" => 99 }).to include subject
-      expect("foo" => { "bar" => :a }).not_to include subject
-    end
-  end
-end

data/spec/fixturama/load_fixture/data.json

@@ -1,5 +0,0 @@
-{
-  "foo": {
-    "bar": <%= id %>
-  }
-}

data/spec/fixturama/load_fixture/data.yaml

@@ -1,3 +0,0 @@
----
-foo:
-  bar: <%= id %>

data/spec/fixturama/load_fixture/data.yml

@@ -1,3 +0,0 @@
----
-foo:
-  bar: <%= id %>

data/spec/fixturama/seed_fixture/_spec.rb

@@ -1,36 +0,0 @@
-RSpec.describe "seed_fixture" do
-  subject { seed_fixture "#{__dir__}/seed.yml" }
-
-  before do
-    FactoryBot.define do
-      factory :foo, class: Hash do
-        transient do
-          bar { 0 }
-          baz { 0 }
-          qux { 0 }
-        end
-
-        trait :bar do
-          bar { 99 }
-        end
-
-        trait :baz do
-          baz { 77 }
-        end
-
-        skip_create
-        initialize_with { { bar: bar, baz: baz, qux: qux } }
-      end
-    end
-  end
-
-  it "runs the factory", aggregate_failures: true do
-    expect(FactoryBot).to receive(:create_list).with(:foo, 1, :baz, qux: 42)
-    expect(FactoryBot).to receive(:create_list) do |*args, **opts|
-      expect(args).to eq [:foo, 3, :bar]
-      expect(opts).to be_empty
-    end
-
-    subject
-  end
-end

data/spec/fixturama/seed_fixture/seed.yml

@@ -1,16 +0,0 @@
----
-- type: foo
-  traits:
-    - baz
-  params:
-    qux: 42
-
-- type: foo
-  count: 3
-  traits:
-    - bar
-
-- type: foo
-  count: 0
-  traits:
-    - baz

data/spec/fixturama/stub_fixture/_spec.rb

@@ -1,120 +0,0 @@
-RSpec.describe "stub_fixture" do
-  subject { arguments.map { |argument| Payment.new.pay(argument) } }
-
-  before do
-    class Payment
-      def pay(_)
-        5
-      end
-    end
-  end
-
-  context "without stubbing" do
-    let(:arguments) { [0] }
-
-    it { is_expected.to eq [5] }
-  end
-
-  context "when message chain stubbed" do
-    before { stub_fixture "#{__dir__}/stub.yml" }
-
-    context "with a :raise option" do
-      let(:arguments) { [0] }
-
-      it "raises an exception" do
-        expect { subject }.to raise_error ArgumentError
-      end
-    end
-
-    context "with a :return option" do
-      let(:arguments) { [1] }
-
-      it "returns stubbed value" do
-        expect(subject).to eq [8]
-      end
-    end
-
-    context "with several actions" do
-      let(:arguments) { [2] * 4 }
-
-      it "calls the consecutive actions and then repeates the last one" do
-        expect(subject).to eq [4, 2, 0, 0]
-      end
-    end
-
-    context "with multi-count actions" do
-      let(:arguments) { [3] * 4 }
-
-      it "repeats the action a specified number of times" do
-        expect(subject).to eq [6, 6, 0, 0]
-      end
-    end
-
-    context "with several arguments" do
-      let(:arguments) { [2, 3, 2, 3, 2, 3] }
-
-      it "counts actions for every stub in isolation from the others" do
-        expect(subject).to eq [4, 6, 2, 6, 0, 0]
-      end
-    end
-
-    context "with partially defined options" do
-      subject { Payment.new.pay(10, overdraft: true, notiy: true) }
-
-      it "uses the stub" do
-        expect(subject).to eq(-5)
-      end
-    end
-
-    context "when options differ" do
-      subject { Payment.new.pay(10, overdraft: false) }
-
-      it "uses universal stub" do
-        expect(subject).to eq(-1)
-      end
-    end
-
-    context "with unspecified argument" do
-      let(:arguments) { [4] }
-
-      it "uses universal stub" do
-        expect(subject).to eq [-1]
-      end
-    end
-  end
-
-  context "when constant stubbed" do
-    before do
-      TIMEOUT = 20
-      stub_fixture "#{__dir__}/stub.yml"
-    end
-
-    it "stubs the constant" do
-      expect(TIMEOUT).to eq 10
-    end
-  end
-
-  context "when http request stubbed" do
-    before { stub_fixture "#{__dir__}/stub.yml" }
-
-    it "stubs the request properly" do
-      req = Net::HTTP::Get.new("/foo")
-      res = Net::HTTP.start("www.example.com") { |http| http.request(req) }
-
-      expect(res.code).to eq "200"
-      expect(res.body).to eq "foo"
-      expect(res["Content-Length"]).to eq "3"
-    end
-
-    def delete_request
-      req = Net::HTTP::Delete.new("/foo")
-      Net::HTTP.start("www.example.com") { |http| http.request(req) }
-    end
-
-    it "stubs repetitive requests properly" do
-      expect(delete_request.code).to eq "200"
-      expect(delete_request.code).to eq "404"
-      expect(delete_request.code).to eq "404"
-    end
-  end
-end