Running feature specs?

[dark-panda]

G'day folks.

I'm writing out a few feature specs for some custom actions and tools I've created, but I'm running into license issues. We have a pro license, but when we run our feature specs we're running into license issues where it says we're running a null license and gives us the banner across the top of the page and whole bit. We're running our specs via Cuprite and Capybara through RSpec. It seems to do a license check when it runs a Puma instance, and the response there doesn't contain the id field, which causes it to revert to a null license. I can't stub this out via the usual RSpec mechanisms because you can only stub out the the calls made within the spec suite itself, and this is coming from the actual Rails server it spins up.

Any thoughts on how we can stub this out for testing?

[adrianthedev]

We run our tests with rspec. Never used Cuprite.
Would you be able to set up a repo where we can run a test to see what the result is?

[dark-panda]

Cuprite is really just a replacement for Selenium to drive the Chrome browser in the end. I've put a simple test repo here:

https://github.com/dark-panda/avo-test

You can run the feature spec and you'll see that two things happen:

• There's a stubbed request that mocks the license fetch in the context of the running spec
• There's a real request that goes out from Puma which runs in a separate thread, and that's the real one that is getting a non-pro license back.

It's the second one that's the issue because from the perspective of the feature spec, the Puma instance isn't running with a pro license, but we do have a pro license. Because the Puma instance is isolated, it doesn't see the specs, and therefore doesn't have its request mocked.

It might be worth just not doing a request when the Rails environment is test?

[Paul-Bob]

Hello @dark-panda. We cloned the test repo and ran the spec with success on both Linux and Mac. We didn't encounter the two situations you described. Could you please provide the .env file and the command used?

[dark-panda]

I'm not saying the specs don't work, what I'm saying is that Avo is being put in a non-pro license mode. For instance, if you inspect the output generated during the spec, you'll see the following in the HTML:

<!-- Avo version: 2.33.0 -->
<!-- Environment: test -->
<!-- License ID:  -->
<!-- License valid?: invalid  -->

The .env file I'm using is the same as the one in the main Avo repo for its specs:

RAILS_ENV=test

POSTGRES_HOST=localhost
POSTGRES_PORT=5432
POSTGRES_USERNAME=postgres
POSTGRES_PASSWORD=

AVO_LICENSE_KEY=license_123

I think I found part of the issue though... in lib/avo/licensing/h_q.rb there's this method:

def normalize_response(response)
  if response.is_a? Hash
    response
  else
    {
      normalized_response: JSON.stringify(response)
    }
  end
  response.merge({})
rescue
  {
    normalized_response: "rescued"
  }
end

A few things I notice here:

• There's an if/else statement there that seems to serve no purpose, since the response.merge({}) line that comes afterward is going to be the return value.
• There's no method called JSON.stringify in Ruby, that's a JavaScript thing, unless that's a monkey patched method or something. In my Rails console, it gives me a NoMethodError.
• Since that line will throw an exception, you'll get back the rescued normalized_response hash below.

That's what I'm seeing at this point, because I have the license check stubbed as follows:

stub_request(:post, 'https://avohq.io/api/v1/licenses/check')
      .with(headers: {
        'Accept' => '*/*',
        'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
        'Content-Type' => 'application/json',
        'User-Agent' => 'Ruby'
      })
      .to_return(
        status: 200,
        headers: {},
        body: {
          id: 'pro',
          valid: true,
          expiry: 1.hour,
          license: 'pro',
          license_key: 'license_123',
          environment: 'test',
          ip: '127.0.0.1',
          host: 'avodemo.herokuapp.test',
          port: 3001
        }.to_json
      )

So the stubbing starts to work, because later on it is caught in normalize_response, but normalize_response throws a rescued exception on JSON.stringify. If you change JSON.stringify to JSON.dump, it still blows up anyways, because when it hits response.merge({}) it throws another NoMethodError since response is a string and not a hash and doesn't have a #merge method. If I replace the normalize_response method with something like this then everything begins to work:

def normalize_response(response)
  if response.is_a? Hash
    response
  else
    JSON.parse(response).merge(
      normalized_response: JSON.dump(response)
    )
  end
rescue
  {
    normalized_response: "rescued"
  }
end

I'm not sure if that's the intent of normalize_response, but it does give us the proper pro license in testing and it now includes the following in the output:

<!-- Avo version: 2.33.0 -->
<!-- Environment: test -->
<!-- License ID: pro -->
<!-- License valid?: valid  -->

At this point I needed to include the pundit gem in my testing app because it was giving me an error about that now that it's in pro mode, but the specs did run successfully with with the pro license validated.

[adrianthedev]

Hey, sorry for the late reply.

The issue is that you don't have the Avo initializer (probably the install command hasn't been run).

Run that and add an .env.test file that has AVO_LICENSE_KEY=license_123 present.

# this should be available for Avo.
# config/intitializers/avo.rb
Avo.configure do |config|
  config.license = "pro"
  config.license_key = ENV["AVO_LICENSE_KEY"]
end

[dark-panda]

We have an initializer in our actual app, but I did miss the file here. After adding the initializer and the .env.test file it's still returning the following in the output during the spec:

<!-- Avo version: 2.34.3 -->
<!-- Environment: test -->
<!-- License ID:  -->
<!-- License valid?: invalid  -->

It's still ending up in the aforementioned noramlize_response method that ends up throwing a rescued exception.