How to use a note in a task

[tfarrar]

I am attempting to retrieve text from GUI and inject the info into an API call, but I am getting stuck using the Note in a task.
The id stored in a note is not usable in my custom task.

This is my API post request task

export class REST_API {
    
    static getData =  (item: string): Task =>
        Task.where(`#actor get api`,
            
            Send.a(PostRequest.to(`/apiget`)
            .using({
                headers: {
                // 'Authorization': `Basic ${token}`,
                }})
                .with({
                    item:item,
                })),
            Log.the(LastResponse.body()),
            Ensure.that(LastResponse.status(), equals(200)),
        );

}

In my test I am trying to do the following

        await actorCalled('ui-user').attemptsTo(
            Navigate.to(url+'/DefaultScreen'),
            notes().set('id',Text.of(ITEM_IN_GUI())),

        );
        await actorCalled('api').attemptsTo(
            REST_API.getData(notes().get('id').toString())

        );

It looks like the task is reading the note as -- <<a note of id>>.as(String)

Is there a way to get the value of the Note. I have tried the following options

notes().get('id').toString()
notes().get('id').as(String).toString()

[jan-molak]

Your approach makes sense, and the implementation is almost correct.

It looks like the task is reading the note as -- <>.as(String)

That's right, as notes().get(name) returns a dynamic Question which needs to be resolved by an Actor.
Calling notes().get('id').toString() returns a description of the Question object rather than its value.

Similarly, calling notes().get('id').as(String).toString() will chain a transformation as(String) to a dynamic value of notes().get('id'), and then .toString() returns the description rather than the value.

I'd suggest making the following improvements:

1. Use an interface to define the structure of your notes
2. Use Answerable<string> instead of just string to allow for dynamic values, such as Question<Promise<string>> and Question<string>
3. Use Question.fromObject({ ... }) to include a dynamic value (itemId) in a static data structure { item: ... }

import { Question, Task } from '@serenity-js/core'

interface MyNotes {                                      // (1)
  id: string;
}

export class REST_API {
  static getData = (itemId: Answerable<string>): Task => // (2)
    Task.where(`#actor gets data`,
      Send.a(PostRequest.to(`/apiget`)
        .using({ 
          headers: {
          // 'Authorization': `Basic ${token}`,
          }
        })
        .with(Question.fromObject({                      // (3)
          item: itemId,
        }))),
      Log.the(LastResponse.body()),
      Ensure.that(LastResponse.status(), equals(200)),
    );
}

Then, in your test scenario:

  await actorCalled('ui-user').attemptsTo(
      Navigate.to(url+'/DefaultScreen'),
      notes<MyNotes>().set('id', Text.of(ITEM_IN_GUI())),
  );
  await actorCalled('api').attemptsTo(
      REST_API.getData(notes<MyNotes>().get('id'))
  );

[lostdog19]

@jan-molak I've got a similar issue using notes, which is causing me a headache. I am calling an API to get a token, and then I need to use that token in subsequent API calls.

First, here's where I get the auth token:

export interface APIActorNotes {
  accessToken?: string;
}

export const getAuthToken = (): Task => {
  const httpCredentials = {
    username: "username",
    password: "password"
  };

  const credentialsBase64 = Buffer.from(`${httpCredentials.username}:${httpCredentials.password}`).toString('base64');

  return Task.where("Get API Auth Token",
    Send.a(PostRequest.to('https://xxxx.xxxxx.xxxxxx.xxx/as/token.oauth2')
      .using({
        headers: {
          'Authorization': `Basic ${credentialsBase64}`,
          'Content-Type': 'application/json'
        },
        params: {
          // PARAMS HERE
        }
      })
      .with({})),
    Ensure.that(LastResponse.status(), equals(200)),
    Ensure.that(LastResponse.body().access_token, isPresent()),
    Log.the(LastResponse.body().access_token),
    notes<APIActorNotes>().set('accessToken', LastResponse.body().access_token) // WHERE I SET accessToken 
  )
}

My other API call:

export const deleteResource = (url: string): Task => {
  const accessToken = notes<APIActorNotes>().get('accessToken');       // WHERE I GET accessToken
  return Task.where("Delete",
    Send.a(DeleteRequest.to(url)
      .using(Question.fromObject({                                  // WHERE I TRY TO GET THE VALUE OF accesstoken
        headers: {
          'Accept': 'application/prs.hal-forms+json',
          'Authorization': "Bearer " + accessToken,
          'Content-Type': 'application/json'
        }
      }))),
    Ensure.that(LastResponse.status(), equals(204)),
  )
}

I've tried various things to get this to work, but I can't get the value out of it. It's always resolving Authorization to "Bearer a note of accessToken".

[jan-molak]

Hey @lostdog19 - your code is almost correct, except for this one line:

export const deleteResource = (url: string): Task => {
  const accessToken = notes<APIActorNotes>().get('accessToken');
  return Task.where("Delete",
    Send.a(DeleteRequest.to(url)
      .using(Question.fromObject({
        headers: {
          'Accept': 'application/prs.hal-forms+json',
          'Authorization': "Bearer " + accessToken,                // <- here's the problem
          'Content-Type': 'application/json'
        }
      }))),
    Ensure.that(LastResponse.status(), equals(204)),
  )
}

One thing you need to remember is that notes return Question objects, which need to be resolved by an Actor. If you concatenate the question with a string before the actor gets a chance to resolve it, instead of the value of the question you get its description.

Questions are conceptually similar to Promise objects in JavaScript, so let's start here and it should all make sense in a moment.

Consider the following example:

const promisedToken = Promise.resolve('my token')
const authorization = 'Bearer ' + promisedToken

console.log(authorization)
// prints: Bearer [object Promise]

If you concatenate 'Bearer ' and promisedToken referencing a Promise object, you get Bearer [object Promise] back.

The same thing happens when you concatenate a string and a Question object:

"Bearer " + accessToken,
// ^- string        ^- question

Here, JavaScript interprets the above as:

"Bearer " + accessToken.toString()

And so, you receive: Bearer a note of accessToken

In JavaScript, you have several options for concatenating a string and the value of a promise.
You can use await to make your code wait for the promise to be resolved before it's concatenated:

const promisedToken = Promise.resolve('my token')
const result = 'Bearer ' + await promisedToken

console.log(result)
// prints: Bearer my token

However, you can also use composition and create a function that receives a promise, resolves it, performs the operation, and returns another promise with the result of the operation:

const authorizationHeader = async (promisedToken: Promise<string>) => {
  const token = await promisedToken
  return 'Bearer ' + await promisedToken
}

const result = await authorizationHeader(Promise.resolve('my token'))

console.log(result)
// prints: Bearer my token

Serenity/JS strongly encourages composition, so in most cases instead of explicitly resolving every question and then operating on their values, you'd create functions that accept and return questions and compose them together.

In your example, you could create an authorizationHeader function that receives a question with a token, resolves it, generates the value of the Authorization header, and returns it as another question:

export const authorizationHeader = (accessTokenQuestion: Question<Promise<string>>) =>
  Question.about('authorization header', async actor => {
    const accessToken = await actor.answer(accessTokenQuestion)
    return 'Bearer ' + accessToken
  })  

With such a helper function in place, the deleteResource task could be implemented as follows:

export const deleteResource = (url: string): Task => {
  const token: Question<Promise<string>> = notes<APIActorNotes>().get('accessToken')
  return Task.where("Delete",
    Send.a(DeleteRequest.to(url)
      .using(Question.fromObject({
        headers: {
          'Accept': 'application/prs.hal-forms+json',
          'Authorization': authorizationHeader(token), // <--
          'Content-Type': 'application/json'
        }
      }))),
    Ensure.that(LastResponse.status(), equals(204)),
  )
}

However, since concatenating the value of a question with a string (or with the value of another question) is a common thing to do, Serenity/JS provides a function called q that simplifies the above implementation

With q, authorizationHeader function becomes:

export const authorizationHeader = (accessTokenQuestion: Question<Promise<string>>) =>
  q`Bearer ${ accessTokenQuestion }`

Or, with a custom description:

export const authorizationHeader = (accessTokenQuestion: Question<Promise<string>>) =>
  q`Bearer ${ accessTokenQuestion }`.describedAs(`authorization header`)

You can also use q inline:

export const deleteResource = (url: string): Task => {
  const accessToken = notes<APIActorNotes>().get('accessToken');  // <- this is fine
  return Task.where("Delete",
    Send.a(DeleteRequest.to(url)
      .using(Question.fromObject({                            
        headers: {
          'Accept': 'application/prs.hal-forms+json',
          'Authorization': q`Bearer ${ accessToken }`,
          'Content-Type': 'application/json'
        }
      }))),
    Ensure.that(LastResponse.status(), equals(204)),
  )
}

Hope this helps!

[lostdog19]

@jan-molak Thanks so much! I'm still trying to get a grasp on Javascript in general with the Promises and such, so I appreciate your detailed response. I applied the inline solution and it's working!