Infrastruttura di Testing JavaScript: Un Framework Completo di Validazione per lo Sviluppo Globale

Nel panorama odierno dello sviluppo software, caratterizzato da ritmi serrati, garantire la qualità e l'affidabilità delle applicazioni JavaScript è fondamentale. Un'infrastruttura di testing solida non è più un lusso, ma una necessità, specialmente per le applicazioni distribuite a un pubblico globale con ambienti utente e aspettative diverse. Questa guida completa esplora i componenti critici di una moderna infrastruttura di testing JavaScript, fornendo una roadmap per costruire un framework di validazione resiliente e scalabile.

Perché Investire in un'Infrastruttura di Testing JavaScript?

Prima di addentrarci nei dettagli, comprendiamo le ragioni fondamentali per cui investire in un'infrastruttura di testing completa è cruciale:

• Bug ed Errori Ridotti: Un testing approfondito identifica ed elimina potenziali bug nelle prime fasi del ciclo di vita dello sviluppo, prevenendo costosi errori in produzione. Immagina una piattaforma di e-commerce globale; un singolo bug nel processo di checkout potrebbe avere un impatto su migliaia di transazioni in diversi paesi e valute.
• Migliore Qualità del Codice: Scrivere test incoraggia gli sviluppatori a scrivere codice più pulito, modulare e manutenibile. L'atto stesso di considerare i casi di test impone una progettazione migliore.
• Cicli di Sviluppo più Rapidi: Il testing automatizzato consente un feedback rapido, permettendo agli sviluppatori di iterare velocemente e con fiducia. Le pipeline di integrazione continua attivano i test automaticamente a ogni modifica del codice, garantendo una validazione immediata.
• Maggiore Fiducia nei Deploy: Una solida suite di test garantisce che le nuove funzionalità o le correzioni di bug non introducano regressioni o rompano le funzionalità esistenti. Questo è particolarmente vitale per applicazioni su larga scala con dipendenze complesse.
• Collaborazione Migliorata: Processi di testing ben definiti promuovono la collaborazione tra sviluppatori, tester e stakeholder, favorendo una comprensione condivisa della qualità e del comportamento dell'applicazione. Una chiara documentazione dei test permette a chiunque nel team di comprendere la strategia di validazione.
• Costi di Manutenzione Ridotti: Trovare e correggere bug in produzione è molto più costoso che individuarli precocemente nello sviluppo. Una forte infrastruttura di testing riduce la probabilità di costosi incidenti in produzione.
• Scalabilità per una Portata Globale: Man mano che la tua applicazione cresce e si espande a livello globale, una strategia di testing ben definita garantisce che rimanga affidabile e performante in diverse regioni, dispositivi e browser. Considera l'impatto della latenza di rete o dei formati di dati specifici per località.

Componenti Chiave di un'Infrastruttura di Testing JavaScript

Un'infrastruttura di testing JavaScript completa è tipicamente composta da diversi componenti chiave, ognuno dei quali affronta diversi aspetti della validazione dell'applicazione:

1. Test Unitari

Il test unitario si concentra sulla verifica della funzionalità di singole unità di codice, come funzioni, classi o moduli, in isolamento. È il fondamento di qualsiasi strategia di testing solida.

Strumenti e Framework:

• Jest: Un framework di testing popolare e ricco di funzionalità sviluppato da Facebook, noto per la sua facilità d'uso, le eccellenti prestazioni e le capacità di mocking integrate. Jest è ampiamente utilizzato nei progetti React e offre un set completo di asserzioni e matcher.
• Mocha: Un framework di testing flessibile ed estensibile che ti permette di scegliere la tua libreria di asserzioni (es. Chai, Assert) e di mocking (es. Sinon.JS). Mocha è altamente personalizzabile e adatto a scenari di testing complessi.
• Jasmine: Un framework di behavior-driven development (BDD) che fornisce una sintassi pulita e leggibile per scrivere i test. Jasmine è spesso utilizzato nei progetti Angular e offre una vasta gamma di matcher per verificare i risultati attesi.
• AVA: Un framework di testing minimalista e "opinionated" che impone le best practice e promuove la concorrenza per un'esecuzione più rapida dei test.

Esempio (Jest):

            
  // math.js
  function add(a, b) {
    return a + b;
  }

  module.exports = add;

  // math.test.js
  const add = require('./math');

  test('somma 1 + 2 per ottenere 3', () => {
    expect(add(1, 2)).toBe(3);
  });

            

              
                Copy
              
            
          

Best Practice per i Test Unitari:

• Scrivere test chiari e concisi: Ogni test dovrebbe concentrarsi su un singolo aspetto della funzionalità dell'unità.
• Seguire il pattern AAA (Arrange, Act, Assert): Struttura i tuoi test per definire chiaramente i passaggi di preparazione, esecuzione e verifica.
• Usare mock e stub per isolare le unità: Effettua il mocking delle dipendenze esterne per evitare di fare affidamento su dati o servizi reali.
• Puntare a un'alta copertura del codice: Cerca di coprire la maggior parte possibile del tuo codice con i test unitari. Strumenti come Istanbul possono misurare la copertura del codice.
• Eseguire i test unitari frequently: Integra i test unitari nel tuo flusso di lavoro di sviluppo per individuare i bug precocemente.

2. Test di Integrazione

Il test di integrazione si concentra sulla verifica dell'interazione tra diverse unità o componenti dell'applicazione. Assicura che le parti funzionino insieme come previsto.

Strumenti e Framework:

• Jest: Può essere utilizzato anche per i test di integrazione, specialmente per testare componenti React che interagiscono tra loro.
• Mocha: Con le librerie di asserzione e mocking appropriate, Mocha fornisce un ambiente flessibile per i test di integrazione.
• Supertest: Una libreria progettata specificamente per testare le API HTTP. Ti permette di inviare richieste ai tuoi endpoint API e verificare le risposte. Utile per testare l'interazione tra il tuo front-end e il back-end.
• Enzyme: Un'utilità di testing per React che facilita l'asserzione, la manipolazione e l'attraversamento dell'output dei tuoi componenti React. Sebbene tecnicamente per i test unitari, è spesso usata per testare come i componenti si integrano con i loro figli.

Esempio (Supertest con Jest):

            
  // app.js (Esempio di app Express)
  const express = require('express');
  const app = express();

  app.get('/users', (req, res) => {
    res.json([{ id: 1, name: 'John Doe' }]);
  });

  module.exports = app;

  // app.test.js
  const request = require('supertest');
  const app = require('./app');

  describe('GET /users', () => {
    it('dovrebbe restituire un elenco di utenti', async () => {
      const res = await request(app).get('/users');
      expect(res.statusCode).toEqual(200);
      expect(res.body).toEqual([{ id: 1, name: 'John Doe' }]);
    });
  });

            

              
                Copy
              
            
          

Best Practice per i Test di Integrazione:

• Identificare i punti chiave di integrazione: Concentrati sul test delle interazioni più critiche tra i componenti.
• Usare dipendenze reali o simulate: Decidi se utilizzare dipendenze effettive (es. database, API) o farne il mock in base alle tue esigenze di testing.
• Scrivere test che coprano scenari diversi: Testa sia i casi positivi che quelli negativi per garantire la robustezza.
• Mantenere i test di integrazione relativamente veloci: Riduci al minimo le dipendenze da servizi esterni lenti per mantenere tempi di esecuzione ragionevoli.

3. Test End-to-End (E2E)

Il test end-to-end simula le interazioni reali dell'utente con l'intera applicazione, dall'interfaccia utente ai servizi di backend. Verifica che l'applicazione funzioni correttamente nel suo insieme.

Strumenti e Framework:

• Cypress: Un framework di test end-to-end moderno e orientato agli sviluppatori che offre eccellenti capacità di debugging, "time travel" e attesa automatica. Cypress è noto per la sua velocità e affidabilità.
• Selenium WebDriver: Un framework versatile e ampiamente utilizzato per automatizzare le interazioni con i browser web. Selenium supporta più browser e linguaggi di programmazione, rendendolo adatto a scenari di testing complessi.
• Puppeteer: Una libreria Node sviluppata da Google che fornisce un'API di alto livello per controllare Chrome o Chromium in modalità headless. Puppeteer è spesso utilizzato per web scraping, automazione e test end-to-end.
• Playwright: Un'altra libreria di automazione cross-browser, simile a Puppeteer, che supporta Chrome, Firefox, Safari ed Edge. Playwright pone l'accento su affidabilità e velocità.

Esempio (Cypress):

            
  // cypress/integration/example.spec.js
  describe('Il Mio Primo Test', () => {
    it('Visita il Kitchen Sink', () => {
      cy.visit('https://example.cypress.io');

      cy.contains('type').click();

      // Dovrebbe trovarsi su un nuovo URL che
      // include '/commands/actions'
      cy.url().should('include', '/commands/actions');

      // Ottieni un campo di input e scrivici dentro
      cy.get('.action-email').type('fake@email.com');

      //  Verifica che il valore sia stato aggiornato
      cy.get('.action-email').should('have.value', 'fake@email.com');
    });
  });

            

              
                Copy
              
            
          

Best Practice per i Test End-to-End:

• Concentrarsi sui flussi utente critici: Dai priorità al test degli scenari più importanti che gli utenti potrebbero incontrare.
• Usare dati di test realistici: Crea dati di test che assomiglino molto ai dati del mondo reale per garantire risultati accurati. Considera la localizzazione e l'internazionalizzazione.
• Automatizzare i test E2E il più possibile: Il testing E2E manuale richiede molto tempo ed è soggetto a errori.
• Eseguire i test E2E in un ambiente dedicato: Evita di eseguire test E2E sulla tua macchina locale o in produzione.
• Monitorare le prestazioni dei test E2E: Tieni traccia dei tempi di esecuzione dei test per identificare e risolvere eventuali colli di bottiglia nelle prestazioni.

4. Test di Regressione Visiva

Il test di regressione visiva rileva cambiamenti visivi non intenzionali nell'interfaccia utente della tua applicazione. Confronta screenshot dell'applicazione prima e dopo le modifiche al codice, evidenziando eventuali discrepanze.

Strumenti e Framework:

• Percy: Una popolare piattaforma di test di regressione visiva che si integra perfettamente con vari framework di testing e sistemi CI/CD.
• Applitools Eyes: Un'altra piattaforma completa di testing visivo che utilizza algoritmi basati sull'IA per rilevare regressioni visive.
• BackstopJS: Uno strumento open-source per i test di regressione visiva che ti permette di definire scenari e confrontare screenshot.
• Jest Image Snapshot: Un matcher di Jest che permette di confrontare immagini e rilevare cambiamenti visivi. Semplice ed efficace per esigenze di regressione visiva di base.

Esempio (Jest Image Snapshot):

            
  // component.test.js
  import React from 'react';
  import renderer from 'react-test-renderer';
  import MyComponent from './MyComponent';

  it('esegue il rendering correttamente', () => {
    const tree = renderer.create().toJSON();
    expect(tree).toMatchImageSnapshot();
  });

            

              
                Copy
              
            
          

Best Practice per i Test di Regressione Visiva:

• Stabilire una baseline: Cattura screenshot iniziali dell'UI della tua applicazione che fungano da punto di riferimento.
• Eseguire regolarmente i test di regressione visiva: Integra i test di regressione visiva nella tua pipeline CI/CD per rilevare i cambiamenti precocemente.
• Esaminare attentamente le differenze visive: Ispeziona manualmente qualsiasi differenza visiva rilevata per determinare se è intenzionale o meno.
• Considerare la compatibilità cross-browser: Assicurati che la tua applicazione appaia coerente su diversi browser e dispositivi.

5. Test di Accessibilità

Il test di accessibilità garantisce che la tua applicazione sia utilizzabile da persone con disabilità. Verifica che l'applicazione aderisca agli standard di accessibilità come le WCAG (Web Content Accessibility Guidelines).

Strumenti e Framework:

• axe-core: Una popolare libreria di testing dell'accessibilità sviluppata da Deque Systems. axe-core può essere integrata in vari framework di testing e fornisce report dettagliati sulle violazioni dell'accessibilità.
• Lighthouse: Uno strumento di auditing delle prestazioni web e dell'accessibilità sviluppato da Google. Lighthouse può essere eseguito dai DevTools di Chrome o come modulo Node.
• WAVE (Web Accessibility Evaluation Tool): Un'estensione per browser che permette di valutare l'accessibilità delle pagine web.
• Pa11y: Uno strumento di testing automatizzato dell'accessibilità che può essere eseguito dalla riga di comando o come servizio web.

Esempio (axe-core con Jest):

            
  // accessibility.test.js
  const axe = require('axe-core');
  const { JSDOM } = require('jsdom');

  const html = `
    
Hello World
    
  `;

  it('non dovrebbe avere violazioni di accessibilità', async () => {
    const dom = new JSDOM(html);
    global.document = dom.window.document;

    const results = await axe.run();
    expect(results.violations).toHaveLength(0);
  });

            

              
                Copy
              
            
          

Best Practice per i Test di Accessibilità:

• Incorporare i test di accessibilità precocemente: Inizia a testare l'accessibilità il prima possibile nel ciclo di vita dello sviluppo.
• Usare strumenti di testing automatizzati: Automatizza i test di accessibilità per individuare rapidamente ed efficientemente le violazioni comuni.
• Condurre test manuali: Integra i test automatizzati con test manuali per identificare problemi di accessibilità più complessi.
• Coinvolgere utenti con disabilità: Ottieni feedback da utenti con disabilità per garantire che la tua applicazione sia veramente accessibile.
• Rimanere aggiornati sugli standard di accessibilità: Tieniti al passo con le ultime linee guida WCAG e le best practice.

Integrazione Continua e Delivery Continua (CI/CD)

Integrare la tua infrastruttura di testing con una pipeline CI/CD è fondamentale per automatizzare il processo di testing e garantire un feedback rapido. Gli strumenti CI/CD eseguono automaticamente i tuoi test ogni volta che vengono committate modifiche al codice, fornendo insight immediati sulla qualità del tuo codice.

Popolari Strumenti CI/CD:

• Jenkins: Un server di automazione open-source ampiamente utilizzato che supporta una vasta gamma di plugin e integrazioni.
• GitHub Actions: Una piattaforma CI/CD integrata direttamente nei repository di GitHub, che offre un flusso di lavoro senza interruzioni per la creazione, il test e il deploy delle applicazioni.
• GitLab CI/CD: Una piattaforma CI/CD integrata in GitLab, che fornisce una soluzione DevOps completa.
• CircleCI: Una piattaforma CI/CD basata su cloud, nota per la sua facilità d'uso e i tempi di build rapidi.
• Travis CI: Un'altra piattaforma CI/CD basata su cloud che si integra perfettamente con GitHub.

Vantaggi dell'Integrazione CI/CD:

• Testing Automatizzato: I test vengono eseguiti automaticamente a ogni commit di codice.
• Feedback più Rapido: Gli sviluppatori ricevono un feedback immediato sulla qualità del loro codice.
• Collaborazione Migliorata: Le pipeline CI/CD promuovono la collaborazione fornendo una visione condivisa della qualità dell'applicazione.
• Deploy più Rapidi: I processi di testing e deploy automatizzati consentono rilasci più veloci e frequenti.
• Rischio Ridotto: Le pipeline CI/CD riducono il rischio di introdurre bug in produzione.

Test di Globalizzazione e Localizzazione (i18n e L10n)

Per le applicazioni destinate a un pubblico globale, è essenziale testare i problemi di globalizzazione (i18n) e localizzazione (L10n). Ciò garantisce che l'applicazione si adatti correttamente a diverse lingue, culture e regioni.

Considerazioni Chiave per i Test i18n e L10n:

• Espansione e Contrazione del Testo: Lingue diverse richiedono quantità di spazio variabili per visualizzare lo stesso contenuto. Testa come la tua applicazione gestisce l'espansione e la contrazione del testo.
• Formati di Data e Ora: I formati di data e ora variano significativamente tra le diverse località. Assicurati che la tua applicazione visualizzi date e ore correttamente per ogni località.
• Formati di Valuta: I simboli di valuta e le convenzioni di formattazione differiscono tra i paesi. Testa che la tua applicazione gestisca correttamente i formati di valuta.
• Formati Numerici: Anche i separatori numerici (es. virgole, punti) variano tra le località. Assicurati che la tua applicazione visualizzi i numeri correttamente.
• Codifica dei Caratteri: Usa una codifica dei caratteri che supporti tutte le lingue che la tua applicazione deve supportare (es. UTF-8).
• Lingue da Destra a Sinistra (RTL): Testa che la tua applicazione gestisca correttamente le lingue RTL come l'arabo e l'ebraico.
• Accuratezza della Traduzione: Assicurati che tutto il testo nella tua applicazione sia tradotto accuratamente nelle lingue di destinazione.

Strumenti e Tecniche per i Test i18n e L10n:

• Pseudo-localizzazione: Sostituisci il testo con stringhe artificiali che simulano gli effetti della traduzione, come l'espansione del testo e i caratteri speciali.
• Librerie di Internazionalizzazione: Usa librerie come `i18next` o `Globalize.js` per gestire le attività di localizzazione nel tuo codice JavaScript.
• Testing di Localizzazione Automatizzato: Usa strumenti come `LokiJS` per verificare l'aspetto visivo dei contenuti localizzati.
• Testing di Localizzazione Manuale: Coinvolgi madrelingua nel processo di testing per garantire l'accuratezza e l'adeguatezza culturale delle traduzioni.

Esempio: Testare un problema di formattazione della data

Considera uno scenario in cui un'applicazione visualizza le date nel formato MM/GG/AAAA. Per gli utenti in Europa, questo potrebbe creare confusione poiché utilizzano tipicamente il formato GG/MM/AAAA. Un test di localizzazione comporterebbe l'impostazione della località su un paese europeo e la verifica che la data venga visualizzata correttamente nel formato GG/MM/AAAA.

Test delle Prestazioni

I test delle prestazioni sono cruciali per garantire che le tue applicazioni JavaScript si carichino rapidamente e rispondano in modo efficiente, specialmente quando si serve una base di utenti globale con condizioni di rete variabili.

Tipi Chiave di Test delle Prestazioni

• Test di Carico (Load Testing): Valuta le prestazioni dell'applicazione sotto il carico utente previsto.
• Test di Stress (Stress Testing): Determina il punto di rottura dell'applicazione superando il carico previsto.
• Test di Resistenza (Endurance Testing): Verifica la stabilità per periodi prolungati sotto un carico costante.
• Test di Picco (Spike Testing): Valuta la reazione a improvvisi ed estremi aumenti di carico.

Strumenti per i Test delle Prestazioni JavaScript

• WebPageTest: Uno strumento open-source per testare le prestazioni di un sito web da più località in tutto il mondo, offrendo metriche dettagliate e visualizzazioni.
• Lighthouse: Integrato nei DevTools di Chrome, Lighthouse fornisce audit delle prestazioni e insight pratici per migliorare i tempi di caricamento delle pagine.
• PageSpeed Insights: Lo strumento di Google che analizza il contenuto di una pagina web e fornisce suggerimenti per renderla più veloce.
• k6: Uno strumento di test di carico open-source progettato per sviluppatori e DevOps, che consente di scrivere test delle prestazioni in JavaScript.
• Artillery: Una moderna piattaforma di test di carico, scritta in Node.js, che offre estensibilità e scalabilità per scenari di prestazioni complessi.

Best Practice per i Test delle Prestazioni

• Testare da più località geografiche: Simula l'accesso reale degli utenti da diverse regioni per identificare problemi di prestazioni specifici a livello geografico.
• Simulare diverse condizioni di rete: Emula varie velocità di rete e latenza per comprendere le prestazioni in diversi ambienti utente.
• Ottimizzare immagini e asset: Riduci le dimensioni dei file per minimizzare i tempi di download.
• Sfruttare la cache del browser: Usa strategie di caching per ridurre il carico sul server e migliorare i tempi di caricamento delle pagine per i visitatori di ritorno.
• Monitorare le prestazioni lato server: Identifica i colli di bottiglia sul server che potrebbero influire sulle prestazioni del frontend.

Monitoraggio e Osservabilità

Implementare solide pratiche di monitoraggio e osservabilità garantisce di avere insight in tempo reale sulla salute e le prestazioni della tua applicazione in produzione, consentendo l'identificazione e la risoluzione proattiva dei problemi che impattano gli utenti globali.

Metriche Chiave di Monitoraggio

• Tassi di Errore (Error Rates): Traccia la frequenza degli errori che si verificano nell'applicazione per identificare potenziali problemi.
• Tempi di Risposta (Response Times): Monitora il tempo impiegato dall'applicazione per rispondere alle richieste degli utenti, indicando colli di bottiglia nelle prestazioni.
• Utilizzo delle Risorse (Resource Utilization): Tieni traccia dell'uso di CPU, memoria e disco sui server per identificare vincoli di risorse.
• Metriche dell'Esperienza Utente (User Experience Metrics): Misura indicatori chiave di prestazione (KPI) come i tempi di caricamento della pagina, il time to first byte (TTFB) e le interazioni degli utenti per comprendere l'esperienza utente.

Strumenti per il Monitoraggio e l'Osservabilità

• New Relic: Una piattaforma di monitoraggio completa che offre insight in tempo reale sulle prestazioni delle applicazioni, sull'infrastruttura e sull'esperienza utente.
• Datadog: Una piattaforma di monitoraggio e analisi che fornisce osservabilità full-stack, consentendo di tracciare metriche, log e trace attraverso la tua infrastruttura e le tue applicazioni.
• Sentry: Una piattaforma di tracciamento degli errori e monitoraggio delle prestazioni progettata per aiutarti a identificare e risolvere gli errori in tempo reale.
• Prometheus: Un toolkit di monitoraggio e allerta open-source progettato per ambienti cloud-native.
• Grafana: Uno strumento di visualizzazione dati open-source che consente di creare dashboard e visualizzare metriche da varie fonti di dati.

Best Practice per il Monitoraggio e l'Osservabilità

• Implementare il logging centralizzato: Raccogli i log da tutti i componenti della tua applicazione in una posizione centrale per un'analisi più semplice.
• Impostare avvisi per eventi critici: Configura avvisi per essere notificato quando si verificano eventi critici, come errori, degradazioni delle prestazioni o violazioni della sicurezza.
• Usare il tracciamento distribuito (distributed tracing): Implementa il tracciamento distribuito per seguire le richieste mentre attraversano la tua applicazione, identificando colli di bottiglia e problemi di prestazioni.
• Visualizzare i dati con le dashboard: Crea dashboard per visualizzare le metriche chiave e identificare le tendenze nel tempo.
• Rivedere e migliorare continuamente la tua strategia di monitoraggio: Rivedi regolarmente la tua strategia di monitoraggio per assicurarti che catturi efficacemente le informazioni necessarie per identificare e risolvere i problemi.

Costruire una Cultura del Testing

Un'infrastruttura di testing solida è efficace solo quanto la cultura che la supporta. Costruire una cultura del testing richiede l'impegno di tutti i membri del team di sviluppo, dagli sviluppatori e tester ai product manager e agli stakeholder.

Elementi Chiave di una Cultura del Testing:

• Responsabilità Condivisa: Il testing non è solo responsabilità del team QA; tutti sono responsabili di garantire la qualità del codice.
• Testing Precoce: Il testing dovrebbe iniziare presto nel ciclo di vita dello sviluppo, non come un'attività secondaria.
• Automazione: Automatizza il più possibile il processo di testing per ridurre lo sforzo manuale e migliorare l'efficienza.
• Miglioramento Continuo: Rivedi e migliora regolarmente i tuoi processi di testing per garantire che siano efficaci ed efficienti.
• Cicli di Feedback: Stabilisci cicli di feedback per condividere i risultati dei test e identificare aree di miglioramento.
• Formazione ed Educazione: Fornisci formazione ed educazione per garantire che tutti abbiano le competenze e le conoscenze necessarie per contribuire allo sforzo di testing.
• Celebrare i Successi: Riconosci e celebra i successi nel testing per rafforzare l'importanza della qualità.

Conclusione

Costruire un'infrastruttura di testing JavaScript completa è un investimento critico per qualsiasi organizzazione che sviluppa e distribuisce applicazioni JavaScript a un pubblico globale. Incorporando test unitari, di integrazione, end-to-end, di regressione visiva e di accessibilità, e integrandoli in una pipeline CI/CD, puoi garantire la qualità, l'affidabilità e la scalabilità delle tue applicazioni. Ricorda di considerare le sfumature della globalizzazione e localizzazione, delle prestazioni e del monitoraggio per offrire un'esperienza utente fluida in diverse regioni e culture. Abbracciare una cultura del testing darà al tuo team il potere di costruire applicazioni di alta qualità con fiducia, portando infine a una maggiore soddisfazione del cliente e al successo aziendale nel mercato globale. Considera di rivedere e adattare regolarmente le tue strategie di testing man mano che la tua applicazione evolve e la tua comprensione delle esigenze degli utenti si approfondisce.