Golang on Haseeb Majid

TIL: How to Debug a Test in Golang With Build Tags in Neovim

Thu, 16 Nov 2023 00:00:00 +0000

TIL: How to Debug a Test in Golang With Build Tags in Neovim

I was having issues with my debugger today (well technically yesterday because I am publishing this a day later to spread out my blog posts but same difference) and it took me a few hours to realise what was going on. In my case, I was trying to debug a test written in Golang using nvim-dap-go on Neovim.

The reason the test was failing because the test file had build tags so delve (the debugger) couldn’t compile the file, i.e. using the unit build tag in the example below.

//go:build unit
// +build unit

package options_test

When we set up the dag-go plugin, we need to pass an extra field called build_flags:

lua require('dap-go').setup {
  delve = {
    build_flags = "-tags=unit,integration,e2e",
  },
}

Replace the above with the tags you use! If you are using NixVim you should be able to do something like this ¹:

{
  programs.nixvim = {
    plugins = {
      dap.extensions.dap-go = {
        enable = true;
        delve = {
          path = "${pkgs.delve}/bin/dlv";
          buildFlags = "-tags=unit,integration,e2e";
        };
      };
    };
  };
}

Then I have a keybinding to debug the nearest test like so, again using NixVim.

  {
    action = " lua require('dap-go').debug_test()";
    key = "td";
    options = {
      desc = "Debug Nearest (Go)";
    };
    mode = [
      "n"
    ];
  }

in lua:

vim.keymap.set("n", "td", "lua require('dap-go').debug_test()")

After this PR is merged, https://github.com/nix-community/nixvim/pull/703 ↩︎

TIL: How to Disable Linters in Golangci Lint for Test Files

Tue, 10 Oct 2023 00:00:00 +0000

TIL: How to Disable Linters in Golangci Lint for Test Files

Today (for once), I ran golangci-lint run and it failed on CI with the following error:

internal/options/parser_test.go:13: Function 'TestParse' is too long (69 > 60) (funlen)
func TestParse(t *testing.T) {
task: Failed to run task "lint": exit status 1

Where my .golangci.yml file looked like this:

run:
  timeout: 5m
  skip-dirs:
    - direnv

linters:
  enable:
    - bodyclose
    - dogsled
    - dupl
    - errcheck
    - exportloopref
    - funlen
    - gochecknoinits
    - goconst
    - gocritic
    - gocyclo
    - gofmt
    - goimports
    - gomnd
    - goprintffuncname
    - gosec
    - gosimple
    - govet
    - ineffassign
    - lll
    - misspell
    - nakedret
    - noctx
    - nolintlint
    - revive
    - staticcheck
    - stylecheck
    - typecheck
    - unconvert
    - unparam
    - unused
    - whitespace

So basically we want the ability to turn off funlen for our tests (and other linters). Because we don’t mind if some of our test functions get a big long with different sub-tests.

How to Use Neotest Dap With Lazyvim for Golang Development

Mon, 31 Jul 2023 00:00:00 +0000

In this blog post, I will show you how you can easily setup Neotest to make testing easier in neovim and DAP to make debugging your tests is a lot easier.

I am using the LazyVim neovim distribution, where these two come as easily installed extra plugins. However, it should be easy enough for you to copy the config over to your neovim lua config. LazyVim even has the config available on its website, you don’t even need to deep dive into the code 😄.

For example with dap. Here are some examples of what it can look like. The two main bits we will look at today don’t come by default with LazyVim but are “extras” we can add them

Neotest

To set up Neotest on LazyVim, go to your LazyVim starter repo. Then open our lazy.lua file and add the following lines:

spec = {
    -- add LazyVim and import its plugins
    { "LazyVim/LazyVim", import = "lazyvim.plugins" },
    -- import any extras modules here
    { import = "lazyvim.plugins.extras.test.core" },
    { import = "lazyvim.plugins.extras.lang.go" },
    -- import/override with your plugins
    { import = "plugins" },
},

Here you can see the output from a test at the bottom (from Neotest) and a test summary (on the right). Using the test summary we can easily run one test at a time, even subtests.

The config that LazyVim sets the following key binds.

keys = {
    { "tt", function() require("neotest").run.run(vim.fn.expand("%")) end, desc = "Run File" },
    { "tT", function() require("neotest").run.run(vim.loop.cwd()) end, desc = "Run All Test Files" },
    { "tr", function() require("neotest").run.run() end, desc = "Run Nearest" },
    { "ts", function() require("neotest").summary.toggle() end, desc = "Toggle Summary" },
    { "to", function() require("neotest").output.open({ enter = true, auto_close = true }) end, desc = "Show Output" },
    { "tO", function() require("neotest").output_panel.toggle() end, desc = "Toggle Output Panel" },
    { "tS", function() require("neotest").run.stop() end, desc = "Stop" },
},

So we can get the test summary by pressing + t + s. Or test output using + t + shift + o. Where is my leader key. Also if a test fails when I run the nearest test + t + n, the output panel (at the bottom) auto opens.

DAP Core

Similar to above to add debugging support we can add an extra plugin like so:

spec = {
    -- add LazyVim and import its plugins
    { "LazyVim/LazyVim", import = "lazyvim.plugins" },
    -- import any extras modules here
    { import = "lazyvim.plugins.extras.dap.core" },
    -- import/override with your plugins
    { import = "plugins" },
},

To debug our tests first we can add a breakpoint using + d + b. Then we can run our test in debug mode using + t + d, which will run the nearest test in debug mode.

When we start to debug our tests it looks something like this. If you have used the VSCode debugger this will look very similar. We can explore the current state, the values various variables have etc. Run commands in the debugger at the bottom.

That’s it! We can improve our testing experience in Go using neovim with Neotest and DAP. I am also able to replicate some features I used to have in VSCode and now also have in neovim 💗.

Appendix

This video helping me get set up by Elijah Manor (he does great videos btw)

TIL: How to Set a Relationship on Golang Pocketbase

Wed, 08 Mar 2023 00:00:00 +0000

TIL: How to Set a Relationship on Golang Pocketbase

Pocketbase is a backend as a service, it is very nice because it is written in Golang it can compile down to a single binary. It also allows us to extend it using Golang and use it as a framework. In my case, I needed some extra logic before adding data to the database so I decided to extend Pocketbase and write some of my business logic.

Part of the code involved adding some entries to the Database including a relationship. However, I noticed that the relationship looked different in the Pocketbase GUI as compared with the ones I created using the Pocketbase client in the SvelteKit part of my app.

The other relationships showed up a bit differently, they didn’t include the id of the relationship (as a foreign key) but rather a field on the other collection. In the example below the relationship field I am referencing is the bookmark_metadata. Which uses the title field.

Where the bookmark metadata may look like:

We can achieve this using the following code:

bookmarkRecord := models.NewRecord(collection)
bookmarkRecord.Set("bookmark_metadata", []string{metadataRecord.Id})
bookmarkRecord.Set("favourite", false)
bookmarkRecord.Set("collection", collectionID)
bookmarkRecord.Set("custom_order", math.MaxInt32)

The key being that we set bookmark_metadata as a slice (array). However, if we did:

bookmarkRecord.Set("bookmark_metadata", metadataRecord.Id)

In the GUI the record would look like this:

Both options will work for setting up a relationship between two collections. I just wanted to show you how you can set it so it shows up like relationship created via the JS SDK. You can read more about creating records with Golang here.

TIL: How To Add Custom Syntax Highlighting Rules in VS Code

Tue, 27 Dec 2022 00:00:00 +0000

TIL: How To Add Custom Syntax Highlighting Rules in VS Code

The other day (a few months ago) I was comparing Goland and VS Code for Golang development. I noticed Goland by default seemed to have nicer syntax highlighting, so I started looking at what I could do in VS Code to do this.

Before

After

It turns out we can do this with our own custom rules using editor.tokenColorCustomizations. To do this go to our settings (settings.json) and add something like:

{
  "editor.tokenColorCustomizations": {
    "[Dracula]": {
      "textMateRules": [
        {
          "scope": "source.go",
          "settings": {
            "foreground": "#6dd8ce"
          }
        }
      ]
    }
  },
}

Where:

Dracula is the colour scheme
scope is the type of token we want to colour

We can find out what we should set the scope as by going to the command palette and selecting Developer: Inspect Editor Tokens and Scopes.

Then go and hover over the different parts of our code and it will tell you what type of token it is ¹.

That’s it!

https://blog.4d.com/setting-up-code-syntax-highlighting-using-the-visual-studio-code-extension/ ↩︎

TIL: How to Use Prettier with Hugo/Golang Templates

Mon, 12 Dec 2022 00:00:00 +0000

TIL: How to Use Prettier with Hugo/Golang Templates

If you try to use prettier on a (Hugo) Golang HTML template you may get something that looks like this:

{{- if or .Params.author site.Params.author }}
  {{- $author := (.Params.author | default site.Params.author) }}
  {{- $author_type := (printf "%T" $author) }}
  {{- if (or (eq $author_type "[]string") (eq $author_type "[]interface {}")) }}
    {{- (delimit $author ", " ) }}
  {{- else }}
    {{- $author }}
  {{- end }}
{{- end -}}

into this

{{- if or .Params.author site.Params.author }} {{- $author := (.Params.author |
default site.Params.author) }} {{- $author_type := (printf "%T" $author) }} {{-
if (or (eq $author_type "[]string") (eq $author_type "[]interface {}")) }} {{-
(delimit $author ", " ) }} {{- else }} {{- $author }} {{- end }} {{- end -}}

This of course something we don’t want. So let’s use a prettier plugin that can solve this problem for us. Let us install npm install --save-dev prettier-plugin-go-template.

Create a .prettierrc file with the following contents:

{
  "overrides": [
    {
      "files": ["*.html"],
      "options": {
        "parser": "go-template"
      }
    }
  ],
  "goTemplateBracketSpacing": true
}

Prettier will now format our HTML files correctly, in our Hugo project.

Optional Settings

By default the format of our files like so:

<a
  href="https://github.com/reorx/hugo-PaperModX/"
  rel="noopener"
  target="_blank"
>a>

If we add the following option to the .prettierrc, "bracketSameLine": true then our file will look like:

<a
  href="https://github.com/reorx/hugo-PaperModX/"
  rel="noopener"
  target="_blank"
>a>

Sometimes our file may look something like this:

<span>
  Analytics by
  <a href="https://{{ .Site.Params.goatcounter }}.goatcounter.com"
    >Goatcounter.a
  >
span>

To fix the dangling > we can add the following option to the .prettierrc file , "htmlWhitespaceSensitivity": "ignore" then our file will look like:

<span>
  Analytics by
  <a href="https://{{ .Site.Params.goatcounter }}.goatcounter.com">
    Goatcounter.
  a>
span>

TIL: How to Separate our Golang Tests

Sun, 04 Dec 2022 00:00:00 +0000

TIL: How to Separate our Golang Tests

Sometimes we want to be able to run our unit tests and integration tests separately. In Golang we can do this using build tags, build tags are used to tell the compiler important information when we run go build ¹.

Let say we have a file called package_test.go. By adding // +build integration to the top of the file without any whitespace. This test file will only be run when we specify the tags in our test command go test --tags=integration.

Our integration test file would look something like:

// +build integration

package mypackage_test

Our unit tests can be left without any build tags and can be run with go test like normal.

To get this to compile correctly with VS Code we need to add the following to settings.json file.

{
  "go.buildFlags": [
      "-tags=integration"
  ],
  "go.testTags": "integration",
}

More about Golang build tags, https://mickey.dev/posts/go-build-tags-testing/ ↩︎

How to create a Golang Web Application using Fizz

Tue, 19 Jan 2021 00:00:00 +0000

Background

A bit of background before we start the article. When I develop a Python web service I use the Connexion library created by Zalando. It’s a great library which is built on top of Flask. It uses an OpenAPI Specification (OAS) file to handle input validation and routing for you. Therefore reducing the boilerplate code you need to write.

The main advantage of this is that we have a design-first approach to developing our API. We fully define the OAS then develop the code/web service. This also keeps the OAS up to date, helping to mitigate the issue of the code/documentation getting out of date. Especially when you share the OAS with other people (clients) to use. The last thing you want to do is give them an out-of-date file.

Anyways short story aside, recently I started learning Golang and developing a simple CRUD web service using Gin. However, I discovered (at least at the time of writing) there was no equivalent library to Connexion. The closest library I could find was Fizz.

What is Fizz?

Fizz almost works the opposite way Connexion does. It generates an OAS file from our code. Now again I prefer the Connexion approach because we just use the OAS file we created at the beginning of the project. However, this is the next best thing.

What I ended up doing was creating an OAS by hand. Then implementing that OAS using Golang and letting Fizz auto-generate the “new” OAS. This “new” OAS is the one that gets shared with clients and is kept up to date. In theory the OAS I defined manually can now be deleted as it’s not required anymore.

This solves the problem of our code getting out-of-date with the specification. Fizz also uses other libraries behind the scenes to help us reduce the boilerplate code similiar to how Connexion works.

Web Service

Now onto the real meat and potatoes of this article. We will create three different endpoints:

GET /healthcheck: Checks if the application is healthy or not
GET /pet/{name}: Get information about a single pet
PUT /pet/{name}: Update information about a single pet

Structure

Our project will follow the structure shown above. We will go (no pun intended 🤷) over what each of the folder “do”.

Core Code

Golang & MongoDB with "Polymorphism" and BSON Unmarshal

Sun, 20 Dec 2020 00:00:00 +0000

Recently I’ve been working on a new personal project called Banter Bus, a browser-based multiplayer game. I’ve been working on a REST API to add new questions to the game. The API is built in Golang and uses MongoDB as the database. Since Golang is a strongly typed language, we will need to specify the structure of the data we expect from the database. This can get tricky if the data varies, such as one field changing.

One issue I encountered was each game type has to have its questions. These questions will be asked to the users playing the game and are stored differently in the database. This is because each game type has different rules and therefore needs a different structure. This means when we unmarshal the data in Golang, we need to specify the structure of these questions. In this article, I will explain how you can create your own unmarshal function. This will allow you to customise the struct that will hold this data (in Golang) returned from MongoDB.

Collection

Imagine the data stored in MongoDB looks something like so:

[
  {
    "game_name": "fibbing_it",
    "questions": {
      "opinion": {
        "horse_group": {
          "questions": [
            "What do you think about horses?",
            "What do you think about camels?"
          ],
          "answers": ["lame", "tasty"]
        }
      },
      "free_form": {
        "bike_group": ["Favourite bike colour?", "A funny question?"]
      },
      "likely": ["to eat ice-cream from the tub", "to get arrested"]
    }
  },
  {
    "game_name": "quibly",
    "questions": {
      "pair": [
        "What do you think about horses?",
        "What do you think about camels?"
      ],
      "answers": ["Favourite bike colour?", "A funny question?"]
    }
  },
  {
    "game_name": "drawlosseum",
    "questions": { "drawings": ["horses", "camels"] }
  }
]

Here you can see each game type has a different structure, due to the different rules each game type will have.

Unmarshal

BSON