# frozen_string_literal: true

require "spec_helper"

describe Split::Persistence::RedisAdapter do
  let(:context) { double(lookup: "blah") }

  subject { Split::Persistence::RedisAdapter.new(context) }

  describe "#redis_key" do
    before { Split::Persistence::RedisAdapter.reset_config! }

    context "default" do
      it "should raise error with prompt to set lookup_by" do
        expect { Split::Persistence::RedisAdapter.new(context) }.to raise_error(RuntimeError)
      end
    end

    context "config with key" do
      before { Split::Persistence::RedisAdapter.reset_config! }
      subject { Split::Persistence::RedisAdapter.new(context, "manual") }

      it 'should be "persistence:manual"' do
        expect(subject.redis_key).to eq("persistence:manual")
      end
    end

    context 'config with lookup_by = proc { "block" }' do
      before { Split::Persistence::RedisAdapter.with_config(lookup_by: proc { "block" }) }

      it 'should be "persistence:block"' do
        expect(subject.redis_key).to eq("persistence:block")
      end
    end

    context "config with lookup_by = proc { |context| context.test }" do
      before { Split::Persistence::RedisAdapter.with_config(lookup_by: proc { "block" }) }
      let(:context) { double(test: "block") }

      it 'should be "persistence:block"' do
        expect(subject.redis_key).to eq("persistence:block")
      end
    end

    context 'config with lookup_by = "method_name"' do
      before { Split::Persistence::RedisAdapter.with_config(lookup_by: "method_name") }
      let(:context) { double(method_name: "val") }

      it 'should be "persistence:bar"' do
        expect(subject.redis_key).to eq("persistence:val")
      end
    end

    context "config with namespace and lookup_by" do
      before { Split::Persistence::RedisAdapter.with_config(lookup_by: proc { "frag" }, namespace: "namer") }

      it 'should be "namer"' do
        expect(subject.redis_key).to eq("namer:frag")
      end
    end
  end

  describe "#find" do
    before { Split::Persistence::RedisAdapter.with_config(lookup_by: proc { "frag" }, namespace: "a_namespace") }

    it "should create and user from a given key" do
      adapter = Split::Persistence::RedisAdapter.find(2)
      expect(adapter.redis_key).to eq("a_namespace:2")
    end
  end

  context "functional tests" do
    before { Split::Persistence::RedisAdapter.with_config(lookup_by: "lookup") }

    describe "#[] and #[]=" do
      it "should set and return the value for given key" do
        subject["my_key"] = "my_value"
        expect(subject["my_key"]).to eq("my_value")
      end
    end

    describe "#delete" do
      it "should delete the given key" do
        subject["my_key"] = "my_value"
        subject.delete("my_key")
        expect(subject["my_key"]).to be_nil
      end
    end

    describe "#keys" do
      it "should return an array of the user's stored keys" do
        subject["my_key"] = "my_value"
        subject["my_second_key"] = "my_second_value"
        expect(subject.keys).to match(["my_key", "my_second_key"])
      end
    end
  end
end