class FakeTwitterClient < Shoegaze::Mock
  # optional. provides in-memory persisted ActiveModel objects so that
  # your mock can 'remember' its state
  extend Shoegaze::Datastore

  mock "Twitter::Client"

  # creates both a FakeTwitterClient::Update 'model' and a FactoryBot
  # factory for the model
  datastore :Update do
    id{ BSON::ObjectId.new }
    date{ Time.new }
    body{ Faker::Lorem.sentence }
    location{ [Faker::Address.latitude, Faker::Address.longitude] }
  end

  implement :update do
    scenario :success do
      # optional. you can provide transforms for your 'models' to
      # represent the data returned by the implementation in various
      # ways
      representer do
        include Representable::JSON

        property :id
        property :date
        property :body

        # notice we omit location in this representation
      end

      # this method will call :as_json on the representer, meaning it
      # will return a hash. you can also call to_json, for example, to
      # return stringified JSON instead
      represent_method :as_json

      datasource do
        # generate an update and store it in the memory store (you can
        # grab it with FakerTwitterClient::Update.find(update.id)
        FactoryBot.create(Update)
      end
    end

    scenario :unavailable do
      datasource do |id|
        raise Twitter::ConnectionFailed.new(Struct.new(:status).new(status: "504"))
      end
    end
  end

  # you can mock chained methods by nesting implementations, too
  #
  # example: ProductMaker.accounts.create({name: "Jack Dorsey"})
  implement :accounts do
    scenario :success do
      datasource do
        implement :create do
          # default scenarios can be specified
          default do |params|
            FactoryBot.create(Account, params)
          end
        end
      end
    end
  end
end

class ProductMaker
  class << self
    def create(name)
      # ...
      twitter_client.update("We have a new product: #{product.name}!")

      product
    end

    private

    def twitter_client
      @twitter_client ||= Twitter::Client.new
    end
  end
end

RSpec.configure do |config|
  config.before :each do
    # swap out the twitter client for the mock in all tests
    stub_const("Twitter::Client", FakeTwitterClient.proxy)
  end
end

describe ProductMaker do
  describe "#create" do
    describe "tweeting" do
      describe "is successful" do
        before :each do
          FakeTwitterClient.calling(:update).with(update.body).yields(:success)
        end

        it "posts a twitter update" do
          product = ProductMaker.create("some_product")

          update = FakeTwitterClient::Update.find_by_body("We have a new product: #{product.name}!")
          expect(update).to exist
        end
      end

      describe "is unavailable" do
        before :each do
          FakeTwitterClient.calling(:update).with(update.body).yields(:unavailable)
        end

        it "raises a Twitter connection failed error" do
          expect{ ProductMaker.create("some_product") }.to raise_exception(Twitter::ConnectionFailed)
        end
      end
    end
  end
end