flipper-cloud 0.28.3 → 1.0.0.pre

data/spec/flipper/cloud/middleware_spec.rb

@@ -1,289 +0,0 @@
-require 'securerandom'
-require 'flipper/cloud'
-require 'flipper/cloud/middleware'
-require 'flipper/adapters/operation_logger'
-
-RSpec.describe Flipper::Cloud::Middleware do
-  let(:flipper) {
-    Flipper::Cloud.new(token: "regular") do |config|
-      config.local_adapter = Flipper::Adapters::OperationLogger.new(Flipper::Adapters::Memory.new)
-      config.sync_secret = "regular_tasty"
-    end
-  }
-
-  let(:env_flipper) {
-    Flipper::Cloud.new(token: "env") do |config|
-      config.local_adapter = Flipper::Adapters::OperationLogger.new(Flipper::Adapters::Memory.new)
-      config.sync_secret = "env_tasty"
-    end
-  }
-
-  let(:app) { Flipper::Cloud.app(flipper) }
-  let(:response_body) { JSON.generate({features: {}}) }
-  let(:request_body) {
-    JSON.generate({
-      "environment_id" => 1,
-      "webhook_id" => 1,
-      "delivery_id" => SecureRandom.uuid,
-      "action" => "sync",
-    })
-  }
-  let(:timestamp) { Time.now }
-  let(:signature) {
-    Flipper::Cloud::MessageVerifier.new(secret: flipper.sync_secret).generate(request_body, timestamp)
-  }
-  let(:signature_header_value) {
-    Flipper::Cloud::MessageVerifier.new(secret: "").header(signature, timestamp)
-  }
-
-  context 'when initializing middleware with flipper instance' do
-    let(:app) { Flipper::Cloud.app(flipper) }
-
-    it 'uses instance to sync' do
-      Flipper.register(:admins) { |*args| false }
-      Flipper.register(:staff) { |*args| false }
-      Flipper.register(:basic) { |*args| false }
-      Flipper.register(:plus) { |*args| false }
-      Flipper.register(:premium) { |*args| false }
-
-      stub = stub_request_for_token('regular')
-      env = {
-        "HTTP_FLIPPER_CLOUD_SIGNATURE" => signature_header_value,
-      }
-      post '/', request_body, env
-
-      expect(last_response.status).to eq(200)
-      expect(JSON.parse(last_response.body)).to eq({
-        "groups" => [
-          {"name" => "admins"},
-          {"name" => "staff"},
-          {"name" => "basic"},
-          {"name" => "plus"},
-          {"name" => "premium"},
-        ],
-      })
-      expect(stub).to have_been_requested
-    end
-  end
-
-  context 'when signature is invalid' do
-    let(:app) { Flipper::Cloud.app(flipper) }
-    let(:signature) {
-      Flipper::Cloud::MessageVerifier.new(secret: "nope").generate(request_body, timestamp)
-    }
-
-    it 'uses instance to sync' do
-      stub = stub_request_for_token('regular')
-      env = {
-        "HTTP_FLIPPER_CLOUD_SIGNATURE" => signature_header_value,
-      }
-      post '/', request_body, env
-
-      expect(last_response.status).to eq(400)
-      expect(stub).not_to have_been_requested
-    end
-  end
-
-  context "when flipper cloud responds with 402" do
-    let(:app) { Flipper::Cloud.app(flipper) }
-
-    it "results in 402" do
-      Flipper.register(:admins) { |*args| false }
-      Flipper.register(:staff) { |*args| false }
-      Flipper.register(:basic) { |*args| false }
-      Flipper.register(:plus) { |*args| false }
-      Flipper.register(:premium) { |*args| false }
-
-      stub = stub_request_for_token('regular', status: 402)
-      env = {
-        "HTTP_FLIPPER_CLOUD_SIGNATURE" => signature_header_value,
-      }
-      post '/', request_body, env
-
-      expect(last_response.status).to eq(402)
-      expect(last_response.headers["Flipper-Cloud-Response-Error-Class"]).to eq("Flipper::Adapters::Http::Error")
-      expect(last_response.headers["Flipper-Cloud-Response-Error-Message"]).to include("Failed with status: 402")
-      expect(stub).to have_been_requested
-    end
-  end
-
-  context "when flipper cloud responds with non-402 and non-2xx code" do
-    let(:app) { Flipper::Cloud.app(flipper) }
-
-    it "results in 500" do
-      Flipper.register(:admins) { |*args| false }
-      Flipper.register(:staff) { |*args| false }
-      Flipper.register(:basic) { |*args| false }
-      Flipper.register(:plus) { |*args| false }
-      Flipper.register(:premium) { |*args| false }
-
-      stub = stub_request_for_token('regular', status: 503)
-      env = {
-        "HTTP_FLIPPER_CLOUD_SIGNATURE" => signature_header_value,
-      }
-      post '/', request_body, env
-
-      expect(last_response.status).to eq(500)
-      expect(last_response.headers["Flipper-Cloud-Response-Error-Class"]).to eq("Flipper::Adapters::Http::Error")
-      expect(last_response.headers["Flipper-Cloud-Response-Error-Message"]).to include("Failed with status: 503")
-      expect(stub).to have_been_requested
-    end
-  end
-
-  context "when flipper cloud responds with timeout" do
-    let(:app) { Flipper::Cloud.app(flipper) }
-
-    it "results in 500" do
-      Flipper.register(:admins) { |*args| false }
-      Flipper.register(:staff) { |*args| false }
-      Flipper.register(:basic) { |*args| false }
-      Flipper.register(:plus) { |*args| false }
-      Flipper.register(:premium) { |*args| false }
-
-      stub = stub_request_for_token('regular', status: :timeout)
-      env = {
-        "HTTP_FLIPPER_CLOUD_SIGNATURE" => signature_header_value,
-      }
-      post '/', request_body, env
-
-      expect(last_response.status).to eq(500)
-      expect(last_response.headers["Flipper-Cloud-Response-Error-Class"]).to eq("Net::OpenTimeout")
-      expect(last_response.headers["Flipper-Cloud-Response-Error-Message"]).to eq("execution expired")
-      expect(stub).to have_been_requested
-    end
-  end
-
-  context 'when initialized with flipper instance and flipper instance in env' do
-    let(:app) { Flipper::Cloud.app(flipper) }
-    let(:signature) {
-      Flipper::Cloud::MessageVerifier.new(secret: env_flipper.sync_secret).generate(request_body, timestamp)
-    }
-
-    it 'uses env instance to sync' do
-      stub = stub_request_for_token('env')
-      env = {
-        "HTTP_FLIPPER_CLOUD_SIGNATURE" => signature_header_value,
-        'flipper' => env_flipper,
-      }
-      post '/', request_body, env
-
-      expect(last_response.status).to eq(200)
-      expect(stub).to have_been_requested
-    end
-  end
-
-  context 'when initialized without flipper instance but flipper instance in env' do
-    let(:app) { Flipper::Cloud.app }
-    let(:signature) {
-      Flipper::Cloud::MessageVerifier.new(secret: env_flipper.sync_secret).generate(request_body, timestamp)
-    }
-
-    it 'uses env instance to sync' do
-      stub = stub_request_for_token('env')
-      env = {
-        "HTTP_FLIPPER_CLOUD_SIGNATURE" => signature_header_value,
-        'flipper' => env_flipper,
-      }
-      post '/', request_body, env
-
-      expect(last_response.status).to eq(200)
-      expect(stub).to have_been_requested
-    end
-  end
-
-  context 'when initialized with env_key' do
-    let(:app) { Flipper::Cloud.app(flipper, env_key: 'flipper_cloud') }
-    let(:signature) {
-      Flipper::Cloud::MessageVerifier.new(secret: env_flipper.sync_secret).generate(request_body, timestamp)
-    }
-
-    it 'uses provided env key instead of default' do
-      stub = stub_request_for_token('env')
-      env = {
-        "HTTP_FLIPPER_CLOUD_SIGNATURE" => signature_header_value,
-        'flipper' => flipper,
-        'flipper_cloud' => env_flipper,
-      }
-      post '/', request_body, env
-
-      expect(last_response.status).to eq(200)
-      expect(stub).to have_been_requested
-    end
-  end
-
-  context 'when initializing lazily with a block' do
-    let(:app) { Flipper::Cloud.app(-> { flipper }) }
-
-    it 'works' do
-      stub = stub_request_for_token('regular')
-      env = {
-        "HTTP_FLIPPER_CLOUD_SIGNATURE" => signature_header_value,
-      }
-      post '/', request_body, env
-
-      expect(last_response.status).to eq(200)
-      expect(stub).to have_been_requested
-    end
-  end
-
-  context 'when using older /webhooks path' do
-    let(:app) { Flipper::Cloud.app(flipper) }
-
-    it 'uses instance to sync' do
-      Flipper.register(:admins) { |*args| false }
-      Flipper.register(:staff) { |*args| false }
-      Flipper.register(:basic) { |*args| false }
-      Flipper.register(:plus) { |*args| false }
-      Flipper.register(:premium) { |*args| false }
-
-      stub = stub_request_for_token('regular')
-      env = {
-        "HTTP_FLIPPER_CLOUD_SIGNATURE" => signature_header_value,
-      }
-      post '/webhooks', request_body, env
-
-      expect(last_response.status).to eq(200)
-      expect(JSON.parse(last_response.body)).to eq({
-        "groups" => [
-          {"name" => "admins"},
-          {"name" => "staff"},
-          {"name" => "basic"},
-          {"name" => "plus"},
-          {"name" => "premium"},
-        ],
-      })
-      expect(stub).to have_been_requested
-    end
-  end
-
-  describe 'Request method unsupported' do
-    it 'skips middleware' do
-      get '/'
-      expect(last_response.status).to eq(404)
-      expect(last_response.content_type).to eq("application/json")
-      expect(last_response.body).to eq("{}")
-    end
-  end
-
-  describe 'Inspecting the built Rack app' do
-    it 'returns a String' do
-      expect(Flipper::Cloud.app(flipper).inspect).to eq("Flipper::Cloud")
-    end
-  end
-
-  private
-
-  def stub_request_for_token(token, status: 200)
-    stub = stub_request(:get, "https://www.flippercloud.io/adapter/features?exclude_gate_names=true").
-      with({
-        headers: {
-          'Flipper-Cloud-Token' => token,
-        },
-      })
-    if status == :timeout
-      stub.to_timeout
-    else
-      stub.to_return(status: status, body: response_body, headers: {})
-    end
-  end
-end

data/spec/flipper/cloud_spec.rb

@@ -1,179 +0,0 @@
-require 'flipper/cloud'
-require 'flipper/adapters/instrumented'
-require 'flipper/instrumenters/memory'
-
-RSpec.describe Flipper::Cloud do
-  before do
-    stub_request(:get, /flippercloud\.io/).to_return(status: 200, body: "{}")
-  end
-
-  context "initialize with token" do
-    let(:token) { 'asdf' }
-
-    before do
-      @instance = described_class.new(token: token)
-    end
-
-    it 'returns Flipper::DSL instance' do
-      expect(@instance).to be_instance_of(Flipper::Cloud::DSL)
-    end
-
-    it 'can read the cloud configuration' do
-      expect(@instance.cloud_configuration).to be_instance_of(Flipper::Cloud::Configuration)
-    end
-
-    it 'configures the correct adapter' do
-      # pardon the nesting...
-      memoized_adapter = @instance.adapter
-      dual_write_adapter = memoized_adapter.adapter
-      expect(dual_write_adapter).to be_instance_of(Flipper::Adapters::DualWrite)
-      poll_adapter = dual_write_adapter.local
-      expect(poll_adapter).to be_instance_of(Flipper::Adapters::Poll)
-
-      http_adapter = dual_write_adapter.remote
-      client = http_adapter.client
-      expect(client.uri.scheme).to eq('https')
-      expect(client.uri.host).to eq('www.flippercloud.io')
-      expect(client.uri.path).to eq('/adapter')
-      expect(client.headers['Flipper-Cloud-Token']).to eq(token)
-      expect(@instance.instrumenter).to be(Flipper::Instrumenters::Noop)
-    end
-  end
-
-  context 'initialize with token and options' do
-    it 'sets correct url' do
-      instance = described_class.new(token: 'asdf', url: 'https://www.fakeflipper.com/sadpanda')
-      # pardon the nesting...
-      memoized = instance.adapter
-      dual_write = memoized.adapter
-      remote = dual_write.remote
-      uri = remote.client.uri
-      expect(uri.scheme).to eq('https')
-      expect(uri.host).to eq('www.fakeflipper.com')
-      expect(uri.path).to eq('/sadpanda')
-    end
-  end
-
-  it 'can initialize with no token explicitly provided' do
-    ENV['FLIPPER_CLOUD_TOKEN'] = 'asdf'
-    expect(described_class.new).to be_instance_of(Flipper::Cloud::DSL)
-  end
-
-  it 'can set instrumenter' do
-    instrumenter = Flipper::Instrumenters::Memory.new
-    instance = described_class.new(token: 'asdf', instrumenter: instrumenter)
-    expect(instance.instrumenter).to be(instrumenter)
-  end
-
-  it 'allows wrapping adapter with another adapter like the instrumenter' do
-    instance = described_class.new(token: 'asdf') do |config|
-      config.adapter do |adapter|
-        Flipper::Adapters::Instrumented.new(adapter)
-      end
-    end
-    # instance.adapter is memoizable adapter instance
-    expect(instance.adapter.adapter).to be_instance_of(Flipper::Adapters::Instrumented)
-  end
-
-  it 'can set debug_output' do
-    expect(Flipper::Adapters::Http::Client).to receive(:new)
-      .with(hash_including(debug_output: STDOUT)).at_least(:once)
-    described_class.new(token: 'asdf', debug_output: STDOUT)
-  end
-
-  it 'can set read_timeout' do
-    expect(Flipper::Adapters::Http::Client).to receive(:new)
-      .with(hash_including(read_timeout: 1)).at_least(:once)
-    described_class.new(token: 'asdf', read_timeout: 1)
-  end
-
-  it 'can set open_timeout' do
-    expect(Flipper::Adapters::Http::Client).to receive(:new)
-      .with(hash_including(open_timeout: 1)).at_least(:once)
-    described_class.new(token: 'asdf', open_timeout: 1)
-  end
-
-  if RUBY_VERSION >= '2.6.0'
-    it 'can set write_timeout' do
-      expect(Flipper::Adapters::Http::Client).to receive(:new)
-        .with(hash_including(open_timeout: 1)).at_least(:once)
-      described_class.new(token: 'asdf', open_timeout: 1)
-    end
-  end
-
-  it 'can import' do
-    stub_request(:post, /www\.flippercloud\.io\/adapter\/features.*/).
-      with(headers: {'Flipper-Cloud-Token'=>'asdf'}).to_return(status: 200, body: "{}", headers: {})
-
-    flipper = Flipper.new(Flipper::Adapters::Memory.new)
-
-    flipper.enable(:test)
-    flipper.enable(:search)
-    flipper.enable_actor(:stats, Flipper::Actor.new("jnunemaker"))
-    flipper.enable_percentage_of_time(:logging, 5)
-
-    cloud_flipper = Flipper::Cloud.new(token: "asdf")
-
-    get_all = {
-      "logging" => {actors: Set.new, boolean: nil, groups: Set.new, percentage_of_actors: nil, percentage_of_time: "5"},
-      "search" => {actors: Set.new, boolean: "true", groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
-      "stats" => {actors: Set["jnunemaker"], boolean: nil, groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
-      "test" => {actors: Set.new, boolean: "true", groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
-    }
-
-    expect(flipper.adapter.get_all).to eq(get_all)
-    cloud_flipper.import(flipper)
-    expect(flipper.adapter.get_all).to eq(get_all)
-    expect(cloud_flipper.adapter.get_all).to eq(get_all)
-  end
-
-  it 'raises error for failure while importing' do
-    stub_request(:post, /www\.flippercloud\.io\/adapter\/features.*/).
-      with(headers: {'Flipper-Cloud-Token'=>'asdf'}).to_return(status: 500, body: "{}")
-
-    flipper = Flipper.new(Flipper::Adapters::Memory.new)
-
-    flipper.enable(:test)
-    flipper.enable(:search)
-    flipper.enable_actor(:stats, Flipper::Actor.new("jnunemaker"))
-    flipper.enable_percentage_of_time(:logging, 5)
-
-    cloud_flipper = Flipper::Cloud.new(token: "asdf")
-
-    get_all = {
-      "logging" => {actors: Set.new, boolean: nil, groups: Set.new, percentage_of_actors: nil, percentage_of_time: "5"},
-      "search" => {actors: Set.new, boolean: "true", groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
-      "stats" => {actors: Set["jnunemaker"], boolean: nil, groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
-      "test" => {actors: Set.new, boolean: "true", groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
-    }
-
-    expect(flipper.adapter.get_all).to eq(get_all)
-    expect { cloud_flipper.import(flipper) }.to raise_error(Flipper::Adapters::Http::Error)
-    expect(flipper.adapter.get_all).to eq(get_all)
-  end
-
-  it 'raises error for timeout while importing' do
-    stub_request(:post, /www\.flippercloud\.io\/adapter\/features.*/).
-      with(headers: {'Flipper-Cloud-Token'=>'asdf'}).to_timeout
-
-    flipper = Flipper.new(Flipper::Adapters::Memory.new)
-
-    flipper.enable(:test)
-    flipper.enable(:search)
-    flipper.enable_actor(:stats, Flipper::Actor.new("jnunemaker"))
-    flipper.enable_percentage_of_time(:logging, 5)
-
-    cloud_flipper = Flipper::Cloud.new(token: "asdf")
-
-    get_all = {
-      "logging" => {actors: Set.new, boolean: nil, groups: Set.new, percentage_of_actors: nil, percentage_of_time: "5"},
-      "search" => {actors: Set.new, boolean: "true", groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
-      "stats" => {actors: Set["jnunemaker"], boolean: nil, groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
-      "test" => {actors: Set.new, boolean: "true", groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
-    }
-
-    expect(flipper.adapter.get_all).to eq(get_all)
-    expect { cloud_flipper.import(flipper) }.to raise_error(Net::OpenTimeout)
-    expect(flipper.adapter.get_all).to eq(get_all)
-  end
-end