Testing & Debugging @ gitlab-org/gitlabdiscussions

Testing & Debugging

This section outlines testing and debugging approaches for the GitLab Discussions feature, ensuring the quality and reliability of the feature.

Testing

Unit Tests: These tests focus on individual components, ensuring that each part functions as intended. Unit tests are essential for isolating problems and ensuring code stability.

Example:

# spec/models/discussion_spec.rb
          require 'rails_helper'
          
          RSpec.describe Discussion, type: :model do
            it 'is valid with a title and body' do
              discussion = build(:discussion, title: 'My Discussion', body: 'This is a discussion.')
              expect(discussion).to be_valid
            end
          
            it 'is invalid without a title' do
              discussion = build(:discussion, title: nil)
              expect(discussion).to_not be_valid
            end
          end

Integration Tests: These tests verify the interaction between different components, ensuring they work together seamlessly. Integration tests are vital for detecting problems arising from the interplay of various parts.

Example:

# spec/features/discussions/create_discussion_spec.rb
          require 'rails_helper'
          
          RSpec.describe 'Creating a Discussion', type: :feature do
            let(:user) { create(:user) }
            let(:project) { create(:project) }
          
            before do
              sign_in(user)
              visit project_path(project)
            end
          
            it 'allows a user to create a discussion' do
              click_link 'New discussion'
              fill_in 'Title', with: 'My Discussion'
              fill_in 'Body', with: 'This is a discussion.'
              click_button 'Create discussion'
          
              expect(page).to have_content('Discussion created')
              expect(page).to have_content('My Discussion')
            end
          end

System Tests: These tests encompass the entire system, simulating real-world scenarios to verify the feature’s overall functionality and behavior. System tests ensure the feature functions as expected in a complete and integrated environment.

Example:

# spec/system/discussions/discussions_spec.rb
          require 'rails_helper'
          
          RSpec.describe 'Discussions', type: :system do
            let(:user) { create(:user) }
            let(:project) { create(:project) }
            let(:discussion) { create(:discussion, project: project) }
          
            before do
              sign_in(user)
              visit project_path(project)
            end
          
            it 'allows users to view discussions' do
              expect(page).to have_content(discussion.title)
            end
          
            it 'allows users to reply to discussions' do
              click_link discussion.title
              fill_in 'Reply', with: 'My reply'
              click_button 'Reply'
          
              expect(page).to have_content('My reply')
            end
          end

End-to-End (E2E) Tests: These tests simulate user interactions from a real browser, ensuring that the feature behaves correctly within the entire application environment. E2E tests guarantee that the feature works as expected from the user’s perspective.

Example:

// cypress/integration/discussions.spec.js
          describe('Discussions', () => {
            beforeEach(() => {
              cy.visit('/projects/gitlab-org/gitlab-discussions')
            })
          
            it('should display discussions on the project page', () => {
              cy.get('.discussion-list').should('be.visible')
            })
          
            it('should allow users to create new discussions', () => {
              cy.get('.new-discussion-button').click()
              cy.get('#discussion_title').type('My Discussion')
              cy.get('#discussion_body').type('This is a discussion.')
              cy.get('.submit-button').click()
          
              cy.get('.discussion-title').should('contain', 'My Discussion')
            })
          })

Manual Testing: While not automated, manual testing plays a crucial role in verifying usability and identifying edge cases that might be missed by automated tests.
- Example: Test creating discussions with various types of content, including large amounts of text, images, and special characters, to evaluate potential issues.
Accessibility Testing: Ensuring the discussions feature is accessible to users with disabilities is paramount. Tools like axe-core can be used to scan for accessibility issues.
- Example:
```
// run accessibility test
          npx axe-core --reporter html --output axe-report.html
          
```

Debugging

Logging: Logging is a powerful tool for understanding the execution flow of the application and identifying potential issues. By carefully examining log messages, developers can track errors and pinpoint problematic areas.

Example:

# app/models/discussion.rb
          class Discussion < ApplicationRecord
            def create
              Rails.logger.info "Creating discussion: #{self.attributes}"
              # ... rest of the create logic
            end
          end

Debugging Tools: Tools like byebug and pry allow developers to pause execution and inspect the current state of the application, providing insights into variables, function calls, and the execution path.

Example:

# app/models/discussion.rb
          class Discussion < ApplicationRecord
            def create
              Rails.logger.info "Creating discussion: #{self.attributes}"
              binding.pry
              # ... rest of the create logic
            end
          end

Browser Developer Tools: Browsers provide powerful tools to inspect the HTML structure, CSS styles, and JavaScript code of web applications. These tools are invaluable for debugging front-end issues and understanding how the application interacts with the user interface.
Performance Monitoring: Tools like New Relic and Sentry provide valuable insights into the performance and health of the application. By monitoring the execution time and error rates, developers can identify areas for improvement and proactively address potential performance bottlenecks.
Profiling: Profiling tools like ruby-prof help identify performance bottlenecks in Ruby code by measuring the execution time of each line of code and providing detailed statistics.