@testomatio/reporter 0.5.10 → 0.6.0-beta.1

package/tests/data/src/services/search_service_test.rb

@@ -0,0 +1,146 @@
+require 'test_helper'
+
+class SearchServiceTest < ActiveSupport::TestCase
+  let(:project) { Project.create title: 'Project 1' }
+  let(:seeder) { Seeder.new project }
+  let(:search_service) { SearchService.new project }
+
+  before(:each) do
+    s = seeder.create_suite title: 'User Management'
+    seeder.create_test suite: s, title: 'Login @auth', state: :automated
+    seeder.create_test suite: s, title: 'Login without password @auth'
+    seeder.create_test suite: s, title: 'Logout @auth'
+    seeder.create_test suite: s, title: 'Disable authorization', state: :automated
+    seeder.create_test suite: s, title: 'Delete account'
+
+    s2 = seeder.create_suite title: 'Product'
+    seeder.create_test suite: s2, title: 'Create product'
+
+    Suite.reindex!
+    Test.reindex!
+  end
+
+  test 'should search tests by title' do
+    Retryable.retryable(tries: 5) do
+      serialized = search_service.find_tests_and_suites 'Login'
+      _(serialized[:included].length).must_equal 2
+      _(found_tests(serialized)).must_include 'Login @auth'
+    end
+  end
+
+  test 'should search tests by tag' do
+    Retryable.retryable(tries: 5) do
+      serialized = search_service.find_tests_and_suites '@auth'
+      assert serialized[:included]
+      _(serialized[:included].length).must_equal 3
+      _(found_tests(serialized)).wont_include 'Disable authorization'
+    end
+  end
+
+  test 'should search tests by title and state' do
+    Retryable.retryable(tries: 5) do
+      serialized = search_service.find_tests_and_suites 'Login', { state: 'automated' }
+      _(serialized[:included].length).must_equal 1
+      _(found_tests(serialized)).must_include 'Login @auth'
+    end
+  end
+
+  test 'should filter tests by state' do
+    serialized = search_service.filter_tests state: 'automated'
+    _(serialized[:included].length).must_equal 2
+  end
+
+  test 'should filter tests by empty state' do
+    sleep 0.3
+    Retryable.retryable(tries: 5) do
+      serialized = search_service.filter_tests state: ''
+      _(serialized[:included].length).must_equal 6
+    end
+  end
+
+  test 'should take description into account' do
+    test = project.tests.find_by title: 'Logout @auth'
+    test.description = 'User account must exist'
+    test.save
+    Retryable.retryable(tries: 5) do
+      test.index!
+      sleep 0.25
+      serialized = search_service.find_tests_and_suites 'Account'
+      echo Test.pluck(:title, :description)
+      _(serialized[:included].length).must_equal 2
+      _(found_tests(serialized)).must_include 'Logout @auth'
+    end
+  end
+
+  test 'should ignore tags in description' do
+    test = project.tests.find_by title: 'Delete account'
+    test.description = 'This is also @auth'
+    test.save
+    Retryable.retryable(tries: 5) do
+      serialized = search_service.find_tests_and_suites '@auth'
+      _(serialized[:included].length).must_equal 3
+      _(found_tests(serialized)).wont_include 'Delete account'
+    end
+  end
+
+  test 'find tests in suites by tag' do
+    s2 = project.suites.last
+    s3 = seeder.create_suite title: 'Cart @slow @important'
+    seeder.create_test suite: s3, title: 'Add to cart'
+    seeder.create_test suite: s3, title: 'Remove from cart @slow'
+    seeder.create_test suite: s3, title: 'Add more to cart'
+
+    seeder.create_test suite: s2, title: 'Add exclusve product @important'
+    TagsService.new(project).rebuild_project_tags
+    tests = search_service.find_tests '@important'
+    echo tests.pluck(:title)
+    _(tests.length).must_equal 4
+    _(tests.pluck(:title)).must_include 'Add exclusve product @important'
+    _(tests.pluck(:title)).must_include 'Add to cart'
+  end
+
+  test 'should find tests on a branch' do
+    test = project.tests.find_by title: 'Delete account'
+    branch = project.branches.create title: 'dev'
+    switch_to_branch branch
+    test.title = 'Remove account'
+    test.save
+
+    sleep 0.25
+    Retryable.retryable(tries: 10) do
+      serialized = search_service.find_tests_and_suites 'Delete'
+      echo serialized[:included]
+      # well, maybe we should not show it but ok :(
+      _(serialized[:included].length).must_equal 1
+
+      serialized = search_service.find_tests_and_suites 'Remove'
+      _(serialized[:included].length).must_equal 1
+    end
+  end
+
+  test 'should search globally by title' do
+    sleep 0.25
+    Retryable.retryable(tries: 10) do
+      suites = SearchService.global_find_tests_and_suites('Login', [project])
+      _(suites.size).must_equal 1
+      _(suites.first[:filtered_tests].size).must_equal 2
+
+      suites = SearchService.global_find_tests_and_suites('@auth', [project])
+      _(suites.size).must_equal 1
+      echo suites.first[:filtered_tests]
+
+      # actually should be 3, because result also includes 'authorization' word
+      _(suites.first[:filtered_tests].size).must_equal 4
+
+      suites = SearchService.global_find_tests_and_suites('Hello', [project])
+      _(suites.size).must_equal 0
+    end
+  end
+
+  private
+
+  def found_tests(serialized)
+    assert serialized[:included]
+    serialized[:included].map { |t| t[:attributes][:title] }
+  end
+end

package/tests/util_test.js

@@ -0,0 +1,51 @@
+const { expect } = require('chai');
+const {
+  fetchFilesFromStackTrace,
+  fetchSourceCodeFromStackTrace,
+ } = require('../lib/util');
+
+describe('Utils', () => {
+  it('#fetchFilesFromStackTrace | should match images from stack trace', () => {
+    const file1 = `${process.cwd()}/tests/data/artifacts/failed_test.png`
+    const file2 = `${process.cwd()}/tests/data/artifacts/screenshot1.png`
+    const stack = `
+PayrollPBTest:everyPayrollIsPositive =
+                              |-------------------jqwik-------------------
+tries = 1000                  | # of calls to property
+checks = 1000                 | # of not rejected calls
+  file:/${file1}
+generation = RANDOMIZED       | parameters are randomly generated
+after-failure = PREVIOUS_SEED | use the previous seed
+edge-cases# file:/${file2}
+edge-cases#total = 12         | # of all combined edge cases
+edge-cases#tried = 12         | # of edge cases tried in current run
+seed = 7004898156813507962    | random seed to reproduce generated values
+    `
+    const files = fetchFilesFromStackTrace(stack);
+    expect(files).to.include(file1);
+    expect(files).to.include(file2);
+  });
+
+  it('#fetchSourceCodeFromStackTrace | prefixed with at ', () => {
+    const stack = `
+Expected: <4.0>
+     but: was <6.0>
+  at ${process.cwd()}/tests/data/cli/RunCest.php:24
+    `
+    const source = fetchSourceCodeFromStackTrace(stack);
+    expect(source).to.include(`$I->executeCommand('run --colors tests/dummy/FileExistsCept.php');`);
+    expect(source).to.include(`24 >`);
+  })
+
+  it('#fetchSourceCodeFromStackTrace | without prefix', () => {
+    const stack = `
+Expected: <4.0>
+     but: was <6.0>
+${process.cwd()}/tests/data/cli/RunCest.php:24
+    `
+    const source = fetchSourceCodeFromStackTrace(stack);
+    expect(source).to.include(`$I->executeCommand('run --colors tests/dummy/FileExistsCept.php');`);
+    expect(source).to.include(`24 >`);
+  })
+
+});

package/tests/xmlReader_test.js

@@ -0,0 +1,232 @@
+const path = require('path');
+const { expect, assert } = require('chai');
+const ServerMock = require('mock-http-server');
+const { host, port, TESTOMATIO_URL, TESTOMATIO, RUN_ID } = require('./adapter/config');
+const { registerHandlers } = require('./adapter/utils');
+const XmlReader = require('../lib/xmlReader')
+
+describe('XML Reader', () => {
+  const server = new ServerMock({ host, port });
+
+  before(done => {
+    server.start(() => {
+      console.log(`[mock-http-server]: Server started at ${TESTOMATIO_URL}`);
+
+      done();
+    });
+  });
+
+  after(done => {
+    server.stop(() => {
+      console.log('[mock-http-server]: Server stopped');
+
+      done();
+    });
+  });
+
+
+  it('should parse Jest XML', () => {
+    const reader = new XmlReader();
+    const jsonData = reader.parse(path.join(__dirname, 'data/junit1.xml'))
+    expect(jsonData.status).to.eql('failed')
+    expect(jsonData.tests_count).to.eql(13)
+    expect(jsonData.tests.length).to.eql(jsonData.tests_count)
+    
+    jsonData.tests.forEach(t => {
+      expect(t).to.contain.keys([
+        'stack',
+        'create',
+        'status',
+        'title',
+        'run_time',
+        'suite_title',
+      ])  
+    })
+  })
+
+
+  it('should parse minitest XML', () => {
+    const reader = new XmlReader();
+    const jsonData = reader.parse(path.join(__dirname, 'data/minitest.xml'))
+    expect(jsonData.status).to.eql('passed')
+    
+    const stats = reader.calculateStats();
+    expect(stats.status).to.eql('passed')
+    expect(stats.tests_count).to.eql(10)
+    expect(jsonData.tests.length).to.eql(stats.tests_count)
+
+    reader.fetchSourceCode();
+
+    jsonData.tests.forEach(t => {
+      expect(t).to.contain.keys([
+        'stack',
+        'create',
+        'status',
+        'file',
+        'title',
+        'run_time',
+        'suite_title',
+      ])  
+    })
+
+    expect(jsonData.tests[0].code).to.be.ok;
+    expect(jsonData.tests[0].code).to.include("test 'should ")
+  })  
+
+  it('should parse Pytest XML', () => {
+    const reader = new XmlReader();
+    const jsonData = reader.parse(path.join(__dirname, 'data/pytest.xml'))
+
+    expect(jsonData.status).to.eql('failed')
+    const stats = reader.calculateStats();
+    expect(stats.status).to.eql('failed')
+    expect(stats.tests_count).to.eql(7)
+    expect(jsonData.tests.length).to.eql(stats.tests_count)
+
+
+    reader.fetchSourceCode();
+    reader.formatErrors();
+    reader.formatTests();
+
+    jsonData.tests.forEach(t => {
+      expect(t).to.contain.keys([
+        'stack',
+        'create',
+        'status',
+        'file',
+        'title',
+        'run_time',
+        'suite_title',
+      ])
+    })
+
+    expect(jsonData.tests[0].title).to.eql("login with valid credentials")
+
+    const failedTests = jsonData.tests.filter(t => t.status === 'failed')
+  })
+
+  it('should parse Codeception XML', () => {
+    const reader = new XmlReader();
+    const jsonData = reader.parse(path.join(__dirname, 'data/codecept.xml'))
+
+    expect(jsonData.status).to.eql('failed')
+    const stats = reader.calculateStats();
+    expect(stats.status).to.eql('failed')
+    expect(stats.tests_count).to.eql(89)
+    expect(jsonData.tests.length).to.eql(stats.tests_count)
+    
+
+    reader.fetchSourceCode();
+    reader.formatErrors();
+    reader.formatTests();
+
+    jsonData.tests.forEach(t => {
+      expect(t).to.contain.keys([
+        'stack',
+        'create',
+        'status',
+        'file',
+        'title',
+        'run_time',
+        'suite_title',
+      ])  
+    })
+
+    expect(jsonData.tests[0].code).to.be.ok;
+    expect(jsonData.tests[0].code).to.include("public function runCestWithTwoFailedTest(")
+    expect(jsonData.tests[0].title).to.eql("run cest with two failed test")
+
+    const failedTests = jsonData.tests.filter(t => t.status === 'failed')
+    const failedTest = failedTests[0];
+    expect(failedTest.stack).to.include('public function')
+  })  
+
+  it('should parse JUnit XML', () => {
+    const reader = new XmlReader();
+    const jsonData = reader.parse(path.join(__dirname, 'data/java.xml'))
+
+    expect(jsonData.status).to.eql('failed')
+    const stats = reader.calculateStats();
+    expect(stats.status).to.eql('failed')
+    expect(stats.tests_count).to.eql(6)
+    expect(jsonData.tests.length).to.eql(stats.tests_count)
+
+
+    reader.fetchSourceCode();
+    reader.formatErrors();
+    reader.formatTests();
+
+    jsonData.tests.forEach(t => {
+      expect(t).to.contain.keys([
+        'stack',
+        'create',
+        'status',
+        'file',
+        'title',
+        'run_time',
+        'suite_title',
+      ])
+    })
+
+    // expect(jsonData.tests[0].code).to.be.ok;
+    // expect(jsonData.tests[0].code).to.include("public function runCestWithTwoFailedTest(")
+    // expect(jsonData.tests[0].title).to.eql("Run cest with two failed test")
+
+    const failedTests = jsonData.tests.filter(t => t.status === 'failed')
+    const failedTest = failedTests[0];
+    expect(failedTest.stack).to.include('(CalculatorTest.java:43')
+  })
+
+  describe('#request', () => {
+
+    before(function () {
+      this.timeout(5000);
+    });
+
+    beforeEach(() => {
+      registerHandlers(server, RUN_ID);
+    })
+
+    it('should create a new run Id', async () => {
+      const reader = new XmlReader({
+        url: TESTOMATIO_URL,
+        apiKey: TESTOMATIO,
+      });
+      reader.parse(path.join(__dirname, 'data/junit1.xml'))
+      await reader.createRun()
+      expect(reader.runId).to.eql(RUN_ID)
+
+      const [req] = server.requests({ method: 'POST', path: '/api/reporter' });
+      const expectedResult = { api_key: TESTOMATIO };
+      assert.isObject(req.body);
+      assert.deepEqual(req.body, expectedResult);
+    });
+
+    it('should publish updates', async () => {
+      const reader = new XmlReader({
+        url: TESTOMATIO_URL,
+        apiKey: TESTOMATIO,
+        runId: RUN_ID,
+      });
+      reader.parse(path.join(__dirname, 'data/junit1.xml'))
+      expect(reader.runId).to.eql(RUN_ID)
+
+      const resp = await reader.uploadData();
+      expect(resp.status).to.eql(200)
+
+      const [req] = server.requests({ method: 'PUT', path: '/api/reporter/' + RUN_ID });
+      assert.isObject(req.body);
+      expect(req.body).to.include({ status: 'failed' })
+    });
+
+
+
+
+    afterEach(() => {
+      server.reset();
+    });
+
+
+  })
+
+});